Amit Kumar on .Net 2.0/3.0/3.5.

Custom Paging In DataList in ASP.Net

2009-07-09T15:57:00.000+05:30

This article we describe DataList Paging with Next, previous and First, Last page access functionality. A numbers list is also displayed for accessing pages faster.

Background
Few days back when I required to implement custom paging in DataList(like a google paging). I search out the Internet but did not find any perfect code. Then after some effort I wrote my own code. I decided to share it with other users. Surely this will help other developers.
For creating the custom paging in the DataList control we need two DataList control, one for displaying the Data from the Database to the DataList and other for handling the Custom Paging.
After it we create three properties
1. CurrentPage
2. FirstPage
3. NextPage
The definition of the CurrentPage Property is
private int CurrentPage
{
get
{
object objPage = ViewState["_CurrentPage"];
int _CurrentPage = 0;
if (objPage == null)
{
_CurrentPage = 0;
}
else
{
_CurrentPage = (int)objPage;
}
return _CurrentPage;
}
set
{
ViewState["_CurrentPage"] = value;

}
}

The definition for the FirstPage property is
private int FirstPage
{
get
{
int _FirstIndex = 0;
if (ViewState["_FirstIndex"] == null)
{
_FirstIndex = 0;
}
else
{
_FirstIndex = Convert.ToInt32(ViewState["_FirstIndex"]);
}
return _FirstIndex;
}
set
{
ViewState["_FirstIndex"] = value;
}
}
The definition for the LastPage property is
private int LastPage
{
get
{
int _LastIndex = 0;
if (ViewState["_LastIndex"] == null)
{
_LastIndex = 0;

}
else
{
_LastIndex = Convert.ToInt32(ViewState["_LastIndex"]);
}
return _LastIndex;
}
set
{
ViewState["_LastIndex"] = value;
}
}
Note:- We need two Member function
Declare it before writing the function, just below the Partial class

PagedDataSource _pageData = new PagedDataSource();

1. BindBlogDataList()
2. handlePaging()

Definition for BindBlogDataList()

private void BindBlogDataList()
{
DataTable dt = _objBlog.BlogContent.GetBlogDetails();
//dataListBlogDetails.DataSource = _objBlog.BlogContent.GetBlogDetails();
//dataListBlogDetails.DataBind();

_pageData.DataSource = dt.DefaultView;
_pageData.AllowPaging = true;
_pageData.PageSize = 10;
_pageData.CurrentPageIndex = CurrentPage;
ViewState["TotalPages"] = _pageData.PageCount;

this.lblPageInfo.Text = "Page " + (CurrentPage + 1) + " of " + _pageData.PageCount;
this.lbtnPrevious.Enabled = !_pageData.IsFirstPage;
this.lbtnNext.Enabled = !_pageData.IsLastPage;
this.lbtnFirst.Enabled = !_pageData.IsFirstPage;
this.lbtnLast.Enabled = !_pageData.IsLastPage;

ddlBlogDetails.DataSource = _pageData;
ddlBlogDetails.DataBind();
this. handlePaging();

}
Definition for handlePaging()
private void handlePaging ()
{
DataTable dt = new DataTable();
dt.Columns.Add("PageIndex");
dt.Columns.Add("PageText");
FirstPage = CurrentPage - 5;
if (CurrentPage > 5)
{
LastPage = CurrentPage + 5;
}
else
{
LastPage = 10;
}
if (LastPage > Convert.ToInt32(ViewState["TotalPages"]))
{
LastPage = Convert.ToInt32(ViewState["TotalPages"]);
FirstPage = LastPage - 10;
}
if (FirstPage < 0)
{
FirstPage = 0;
}
for (int i = FirstPage; i < LastPage; i++)
{
DataRow dr = dt.NewRow();
dr[0] = i;
dr[1] = i + 1;
dt.Rows.Add(dr);
}
this. ddlPaging.DataSource = dt;
this. ddlPaging.DataBind();
}

Details of Default.aspx.cs file
protected void ddlPaging_ItemCommand(object source, DataListCommandEventArgs e)
{
if (e.CommandName.Equals("Paging"))
{
CurrentPage = Convert.ToInt16(e.CommandArgument.ToString());
this.BindBlogDataList();
}
}

protected void ddlPaging_ItemDataBound(object sender, DataListItemEventArgs e)
{
LinkButton lnkbtnPage = (LinkButton)e.Item.FindControl("lnkbtnPaging");
if (lnkbtnPage.CommandArgument.ToString() == CurrentPage.ToString())
{
lnkbtnPage.Enabled = false;
lnkbtnPage.Style.Add("fone-size", "14px");
lnkbtnPage.Font.Bold = true;

}
}

//Page Load
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
BindBlogDataList();
}

}
//First Link Button Click
protected void lbtnFirst_Click(object sender, EventArgs e)
{
CurrentPage = 0;
BindBlogDataList();
}
//Previous Link Button Click
protected void lbtnPrevious_Click(object sender, EventArgs e)
{
CurrentPage -= 1;
BindBlogDataList();

}
//Next Link Button Click
protected void lbtnNext_Click(object sender, EventArgs e)
{
CurrentPage += 1;
BindBlogDataList();
}
//Last Link Button Click
protected void lbtnLast_Click(object sender, EventArgs e)
{
CurrentPage = (Convert.ToInt32(ViewState["TotalPages"]) - 1);
BindBlogDataList();

}

Template

2009-02-02T18:45:00.000+05:30

Style And Control Template In WPF

2009-02-02T15:03:00.000+05:30

Style is a set of properties that is to be applied to range of contents, for example text, images, label,e.t.c.
In WPF, a style is also a set of properties applied to content used for visual rendering. A style can be used to set properties on an existing visual element, such as setting the font weight of a Button control, setting of the background color of the TextBox control or it can be used to define the way an object looks, such as showing the name and age from a Person object. In addition to the features in word processing styles, WPF styles have specific features for building applications, including the ability to associate different visual effects based on user events, provide entirely new looks for existing controls, and even designate rendering behavior for non-visual objects. All of these features come without the need to build a custom control.
In other words the function of the Style is very similar to the .CSS in web application programming.

These are the following different types of Style in WPF

Inline Style
Named Style
Element typed Style
Data Template and Style
Control Template

As an example of how styles can make themselves useful in WPF, let’s take a simple implementation of Button control.

WPF Inline Style

Each and every "style-able" element in WPF has a Style property, which can be set inline using standard XAML property-element syntax. For setting the Style property of an element we use the Style and Setter. Trough Setter tag we set the value of the element properties .

Let's take an example of the Button

Because we want to bundle three property values into our style, we have a Style element with three Setter sub-elements, one for each property we want to set—i.e., FontSize , FontWeight and Background—those with the Button prefix to indicate the class that contains the property. Properties suitable for styling are dependency properties.

Limitation With Inline Style

Inline styles can’t be shared across elements, inline styles actually involve more typing than just setting the properties. For this reason, inline styles aren’t used nearly as often as named styles.

Named Style in WPF
By publishing the same inline style into a resource, and giving a name, then we can use it by its name in our element instance.
Note:- To use the Named Style we use the StaticResource element of the style attribute

ANTS Profiler :- For Performance profiling and Memory Profiling.

2009-01-30T16:28:00.000+05:30

ANTS Profiler is a product of RedGate software company i.e used to check the performance of the .Net code as well as the Memory profiling of the .Net codes.

ANTS Profiler comes in two edition:-

1. Standards
2. Pro

You can download the trial version of the ANTS profiler for only 14 days.

ANTS Profiler is a code profiling tool designed for .NET developers who want to get to the bottom of these and other related issues. Technical testers also use ANTS Profiler to pin bugs down to a specific line of code or to determine scope for optimization.

ANTS Profiler allows you to identify slow lines of code in .NET applications within 5 minutes of installation, allowing you to get on with what you do best – writing code. The program can also be used to measure line-level timings and method execution times, and to understand how your application performs.

ANTS Prifiler profile the following application:-
1. Windows Application
2. ASP.Net Web Application
3. .Net Web Services
4. COM + Application
5. Other application written in any other languages that supports the .Net Framework

You can use ANTS Profiler with the following versions of the .NET Framework:
1.1 (32-bit applications only)
2.0 (32-bit or 64-bit applications)
3.0/3.5. (32-bit or 64-bit applications)

ANTS Profiler is built with .NET 2.0, you will need to install .NET 2.0 in order to be able to use the tool.

ANTS Profiler offers the following features

Profile any .NET language.
Profile ASP.NET web applications.
Profile Windows Forms applications.
Profile .NET 3.0 and .NET 3.5 applications:- WPF, WCF, WF, XBAP
Profile web applications on IIS 5, IIS 5.1, IIS 6, IIS 7, and ASP.NET
Support for 64-bit profiling on x64 processors.
Integration with Visual Studio 2005 and 2008
Call tree which auto-expands the worst performing stack traces.

Besides the above mentioned features, it also support some additional fearures

Method-level profiling (faster mode) which introduces less overhead than when the profiler also records line-level timings.
Profile memory to understand how your application uses memory, and to locate memory leaks. The memory profiler allows you to take snapshots at any point in the execution of your program, so you can see what memory is in use at that point. You can take multiple snapshots at different times while your application is running, so you can compare application memory states.

Display a list of all fonts installed on a computer using Windows Forms and WPF Application

2009-01-06T18:32:00.000+05:30

For displaying all the fonts available on your computer in Windows Application, we use InstalledFontCollection class. It is a sealed class, so that it is not inheritable. InstalledFontClass is available under the System.Drawing.Text namespace.

This class returns an array containg all the installed font on your system. Lets see, the following example express how to use the InstalledFontCollection and display the list of fonts in the ListBox control.

The following steps are required to use InstalledFontCollection Class for displaying all the installed font of your computer in the ListBox control.

Step 1: Create a new WinForm application. Open VS 2005 or VS 2008 > File > New > Project > Choose either Visual Basic or Visual C# in the Project Types > Choose Windows Forms application in Templates> Give a Name to the project and click OK.

Step 2: Drag and drop a Listbox on the form. We will display the list of available fonts in the listbox.

Step 3: In the ‘Form1.cs’, add a reference to the System.Drawing.Text namespace. This namespace contains the ‘InstalledFontCollection’ class which contains the functionality to represent the installed fonts.
C#
using System.Drawing.Text;

Note:- If you r using VB.Net use the following lines of code for adding the System.Drawing.Text namespace
VB.NET
Imports System.Drawing.Text
Step 4: In the Form1_Load, we will create an instance of the ‘InstalledFontCollection’ class and then use the Families property to return an array of ‘FontFamily’ objects associated with the FontCollection class. The font family names are then added to the listbox on each loop.
C#
private void Form1_Load(object sender, EventArgs e)
{
InstalledFontCollection fonts = new InstalledFontCollection();
try
{
foreach (FontFamily font in fonts.Families)
{
listBox1.Items.Add(font.Name);
}
}
catch
{
}
}

Displaying all the installed font of your computer in WPF Application the following codes are useful.

The following XAML code is used for displaying all the installed font of your computer in the ComboBox control. For creating a WPF application choose the WPF templete from the new project dialog box. For creating a WPF application we need .Net 3.5 Framework and Visual Studio 2008.

ListView and XMLDatabinding using XMLDataProvider and Embed a .XML file

2008-08-28T18:04:00.000+05:30

In this article, I explain how to embed an .xml file into the current Assembly.

If the location of an application is changed by the end user, the application is not running well. To overcome this problem in .Net 3.5. the PackUri is used to embed resource to the current assembly. So that if the location or name of the application programm folder is changed the application runs well. This is the main benefit for embedding the resources.

In this I explain both technique for embedding resources to assembly. Using .XAML and code behind file i.e XAML.cs

1) Embedding resources Using .XAML code

The Following steps are required for embedding resource to assembly using XAML code:-

Step:-1. Create a ListView Control the .XAML code. Or create the control to which you want to bind it using XMLDataProvider . In this example I use ListView Control.

Step:-2. Create an XML file for data. In this example i create data.xml file;
Step:-3 Open the Solution Explorer
Step:-4 Select the .xml file.
Step:-5 Right Click the mouse button and select Properties.
Step:-6 Set its Build Action to Resource, if not set.

The Following code helps you to embed .XML file

<Window.Resources>

</XmlDataProvider>

</Window.Resources>

Note:- If you want to bind the resources Compile time use the "pack://application:,,,/resources.xaml"

If you want to bind the resources Run time use the "pack://siteoforigin:,,,/resources.xaml"

Note:- If the resources is in subfolder mention the subfolder name like this

"pack://application:,,,/subfolderName/resources.xaml"

Note Create data.xml File:-

<?xml version="1.0" encoding="utf-8" ?>

<Name>Amit Kumar</Name>

<Country>Sesame Street</Country>

</Customer>

<Name>Anil SinghName>

<Country>United KingdomCountry>

</Customer>

<Name>Kimar Alok</Name>

<Country>Spain</Country>

</Customer>

<Name>Harmeet Singh</Name>

</Customer>

</Customer>

<Name>Sachin</Name>

</Customer>

<Name>Rajesh</Name>

</Customer>

<Name>Govind Verma</Name>

</Customer>

<Name>Sachin Sharma</Name>

<Country>India</Country>

</Customer>

</Customers>

Note:- Here is the complete code for embed .xml file, and bind it to the ListView Control.

<Window x:Class="ListViewControlAndXmlDataFile.Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="ListView Demo" Height="280" Width="500" Loaded="Window_Loaded">

<Window.Resources>

<XmlDataProvider x:Key="empData" Source="pack://application:,,,/data.xml"

XPath="Customers">

</XmlDataProvider>

<Setter.Value>

</LinearGradientBrush>

</Setter.Value>

</Setter>

</Style>

<Setter.Value>

</LinearGradientBrush>

</Setter.Value>

</Setter>

<Style.Triggers>

</Trigger>

</Style.Triggers>

</Style>

</Window.Resources>

<ListView Name="myListView" ScrollViewer.VerticalScrollBarVisibility="Auto"

ItemsSource="{Binding Source={StaticResource empData}, XPath=Customer}"

ItemContainerStyle="{DynamicResource MyItemContainerStyle}">

<ListView.View>

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn.CellTemplate>

</TextBlock>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

</GridView>

</ListView.View>

</ListView>

</Grid>

</Window>

XAML.cs code for embedding resource:-

private void Window_Loaded(object sender, RoutedEventArgs e)

{

Uri uri = new Uri("pack://application:,,,/ListViewControlAndXmlDataFile/ListViewControlAndXmlDataFile/date.xml");

String dataFile = uri.LocalPath;

DataSet ds = new DataSet("Table");//Create a Dataset object

ds.ReadXml(file);// Read the xml file and store it in dataset object ds;

ds.ReadXml(dataFile);

myListView.DataContext = ds.Tables[0].DefaultView; //Update the listView by setting the dataContext

}

Used Namespace;

using System.Data;

using System.IO.Packaging;

Thanking U.

Start And Stop An Animation Using StoryBoard

2008-08-26T18:35:00.000+05:30

In this article, i am going to explain how you can start and stop an animation using StoryBoard
on the click event of the Start Animation and Stop button from the user interface.

Note:- In this article you also learn how to use the RadialGradienBrush and customize the default interface of the Button in the WPF application using the Template.

Note:- First, I explain how to use RadialGradientBrush.
Caution:- To use animation using StoryBoard, RadialGradient is not necessary.

.XAML Code for RadialGradientBrush is :-

<Grid.Background>

</RadialGradientBrush>

</Grid.Background>

</Grid>

Note:- Use ControlTemplate to customize the default appearance of the Control in WPF.

We use ControlTemplate For customize the appearance of Button control:-

Here is the .XAML code for it:-

<Button Name="btnStartAnimation" FontSize="10" FontWeight="Bold" Content="Render Transform" Canvas.Left="100" Canvas.Top="75"

RenderTransformOrigin="0.5,0.5">

<Button.Template>

<Grid>

</Grid>

</ControlTemplate>

</Button.Template>

<Button.RenderTransform>

</Button.RenderTransform>

</Button>

Note:- Here is the complete .XAML code for start and Stop Animation using StoryBoard

<Window x:Class="WpfApplication1.Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="WPF Start and stop Storyboard Animation" Height="400" Width="450" WindowStyle="ToolWindow" ResizeMode="NoResize">

<Grid.Background>

</RadialGradientBrush>

</Grid.Background>

<Canvas.Background>

</RadialGradientBrush>

</Canvas.Background>

<Path.Data>

</PathFigure>

</PathGeometry>

</Path.Data>

</Path>

<TextBlock FontSize="15" Foreground="White" HorizontalAlignment="Center" Canvas.Left="80" Canvas.Top="30">WPF Animation</TextBlock>

<Button.Template>

<Grid>

</Grid>

</ControlTemplate>

</Button.Template>

<Button.RenderTransform>

</Button.RenderTransform>

</Button>

<Canvas.Triggers>

<EventTrigger.Actions>

<DoubleAnimation

Storyboard.TargetName="rotate"

Storyboard.TargetProperty="Angle"

From="0"

To="360"

FillBehavior="Stop"

Duration="0:0:2"

RepeatBehavior="Forever">

</DoubleAnimation>

</Storyboard>

</BeginStoryboard>

</EventTrigger.Actions>

</EventTrigger>

<EventTrigger.Actions>

</EventTrigger.Actions>

</EventTrigger>

</Canvas.Triggers>

</Canvas>

</StackPanel>

</Grid>

</Window>

Note:- Press F5 to run this application, it looks like this. It has two button Rotate Transform and Stop;

When the user click on the Rotate Transform button the animation start, and when user click on Stop button the animation stops.

Note:- The animated windows looks like this:-

Thanking U.

ListView And XmlDataBinding in WPF

2008-08-09T19:19:00.001+05:30

In this article, I am going to explain how to extract data from xml data and show it on a page using WPF ListView control.

I am using data.xml data file , and the binding properties in XAML code.

Here is the .XAML code

<Window x:Class="WpfApplication2.Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="ListView Demo" Height="280" Width="500" Loaded="Window_Loaded">

<ListView Name="myListView" ScrollViewer.VerticalScrollBarVisibility="Auto"

ItemTemplate="{DynamicResource dateTimeFormatTemplate}" ItemsSource="{Binding Path=Table}"

ItemContainerStyle="{DynamicResource MyItemContainerStyle}">

<ListView.View>

<GridViewColumn.CellTemplate>

</GridViewColumn.CellTemplate>

<GridViewColumn.CellTemplate>

</DataTemplate>

<GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

</GridView>

</ListView.View>

</ListView>

</Grid>

<Window.Resources>

</XmlDataProvider>

<Setter.Value>

<GradientStop Offset="1.0" Color="#F4F3F3">GradientStop>

</LinearGradientBrush>

</Setter.Value>

<Style>

<Setter.Value>

</LinearGradientBrush>

Setter.Value>

<Style.Triggers>

</Trigger>

</Style.Triggers>

</Style>

</Window.Resources>

</Window>

Now create the data.xml file by selecting add new item option, by right clicking the mouse button on the solution explorer.

Here is the data.xml file

xml version="1.0" encoding="utf-8" ?>

<Name>Amit KumarName>

<Country>Sesame StreetCountry>

</Customer>

<Name>Anil SinghName>

<Country>United KingdomCountry>

</Customer>

<Name>Kimar AlokName>

<Country>SpainCountry>

Customer>

<Name>Harmeet SinghName>

<Country>MarsCountry>

</Customer>

<Country>MarsCountry>

</Customer>

<Name>SachinName>

<Country>U.K.Country>

</Customer>

<Name>RajeshName>

<Country>U.S.A.Country>

</Customer>

<Name>Govind VermaName>

<Country>MarsCountry>

</Customer>

<Name>Sachin SharmaName>

<Country>IndiaCountry>

</Customer>

</Customers>

Now add the following code in the windows1.xaml.cs file on the windows load event.

private void Window_Loaded(object sender, RoutedEventArgs e)

{

string file = @"D:\Amit\WPFApplication\ListViewItems\ListViewItems\data.xml";

DataSet ds = new DataSet("Table");

ds.ReadXml(file);

myListView.DataContext = ds.Tables[0].DefaultView;

}

Note:-Use the given Namespace

using System.Data;

Change Title bar of a window from another thread

2008-08-06T19:25:00.000+05:30

If you have to change the title bar of a Windows in WPF application from another thread, the following code snippet helps you.

Note:- In the given code snippet the title bar of a windows is changed when the user click on the Change Title button.

Create a user interface using the following code:-

<Window x:Class="WpfApplication1.Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Window1" Height="300" Width="300">

<Grid>

<Button Name="btnTitleChange" Content="Change Title" Width="100" Height="50" Click="btnTitleChange_Click">Button>

<Grid>

Note:-

Now your user interface look like this:-

Now write the following code in the code file ie window1.xmal.cs:-

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Threading;

using System.Windows.Threading;

namespace WpfApplication1

{

///

/// Interaction logic for Window1.xaml

///

public partial class Window1 : Window

{

Window1 win;

public Window1()

{

InitializeComponent();

}

private void btnTitleChange_Click(object sender, RoutedEventArgs e)

{

Thread winTitle = new Thread(new ParameterizedThreadStart(DoWork));

winTitle.Start(this);

}

public void DoWork(object obj)

{

win = (Window1)obj;

win.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(setTitle));

}

public void setTitle()

{

win.Title = "Windows Title Changed From Other Thread:-Amit Kumar";

}

Note:- Run the Application by pressing F5 functional key, and click on the Change Title button, the windows looks like this:-

Calculating the difference between two dates in c#.net.

2008-08-04T19:37:00.000+05:30

To find out the difference between two days in c#.net is not directly possible. For this We use the Subtract() method of the TimeSpan class.

The following code snippet helps you for calculating the difference between two dates:-

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Threading;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();

}
private void btnDate_Click(object sender, EventArgs e)
{

string MyString = "Jan 1, 2002, 10:12:50";
DateTime MyDateTime = DateTime.Parse(MyString);
DateTime currentDate = DateTime.Now;//Getting the current system date and time;
TimeSpan span = currentDate.Subtract(MyDateTime);
int days = span.Days;
int hours = span.Hours;
int minute = span.Minutes;
int second = span.Seconds;
int milisecond = span.Milliseconds;

}
}
}

Note:- The TimeSpan class is capable of returning difference interms of Days, Hours, Minutes, Seconds and Milliseconds only. It is not having a property to show difference interms of Months and years.

Creating a Table Using Sql Server Compact 3.5. Using SqlServer Management Studio Express

2008-08-02T19:25:00.000+05:30

"The following steps help you to create a table in Sql Server Comapct Edition 3.5."

Open the Sql Server Management Studio Express, by clicking on start button on taskbar, select Programm, and then click on Sql Server Management Studio Express, the Sql Server Management Studio Express dialog box appears

2. Select the Sql Server Compact Edition form the Server Type drop down list.

3. Click on the Database File Drop down list and select the New Database, another dialogbox appears, for configuraing the database

which looks similar to this

4.Cick on the browse button and choose the path where you want to save the database file. By default the extension of the database file is .sdf

5. Set the password, if required, otherwise click on the Ok button, a warning message appers.

6.Click on yes to continue or on No to go back to the Change the password.

7.Finally click on the connect button. Now the Sql Server Compact 3.5. is connected.

8. Click on the New Query from the Toolbar,

9. Write the script.

Scripting for creating a table

create table employee

(

EmpId bigint primary key identity(1,1) not null,

address nvarchar(100) not null,

J_O_D datetime not null,

Status nvarchar(4000)

)

11.Select the script and press F5 function key,

A script executed successfully is displayed.

DispatcherTimer

2008-08-01T15:33:00.000+05:30

DispatcherTimer is a timer which is integrated with the Dispatcher queue. It is available under the System.Windows.Threading Namespace. It is simply a class, but it is not typically used in the XAML file.

The DispatcherTimer is not guaranteed to execute a work item, when the DispatcherTimer time interval occurs, but they are guaranteed not to execute a work item before the DispatcherTimer time interval occurs. The reason why is that the DispatcherTimer operation are placed in the Dispatcher queue like other operations.When the DispatcherTimer operation executes is dependent on the other jobs in the queue and their priorities. The higer priorities jobs execute first and the the lower priorities.

Note:- You can explicitly set the priority of the jobs, using the DispatcherPriority Enumeration.

DispatcherPriority describes the priorities at which operations can be invoked by way of the Dispatcher.

The followings are the value of the DispatcherPriority enumeration

public enum DispatcherPriority

Member Discription

Invalid:- The enumeration value is -1. This is an invalid priority.
Inactive:- The enumeration value is 0. Operations are not processed.
SystemIdle:- The enumeration value is 1.Operation is processed when the system is idle.
ApplicationIdle:- The enumeration value is 2. Operation is processed when the app is idle.
ContextIdle:-The enumeration value is 3. Operations are processed after background operations have completed.
Background:-The enumeration value is 4. Operations are processed after all other non-idle operations are completed.
Input:-The enumeration value is 5. Operations are processed at the same priority as input.
Loaded:-The enumeration value is 6. Operations are processed when layout and render has finished but just before items at input priority are serviced. Specifically this is used when raising the Loaded event.
Render:-The enumeration value is 7. Operations processed at the same priority as rendering.
DataBind:-The enumeration value is 8. Operations are processed at the same priority as data binding.
Normal:-The enumeration value is 9. Operations are processed at normal priority. This is the typical application priority.
Send:-The enumeration value is 10. Operations are processed before other asynchronous operations. This is the highest priority.

DispatcherTimerConstructor:-
These are the following constructor of DispatcherTimer to construct an new instance of the DispatcherTimer.

DispatcherTimer() :- It is a no parameter constructor to initialize a new instance of the DispatcherTimer class.

e.g.

System.Windows.Threading
class DispatcherTimerDemo
{
DispatcherTimer timer=new DispatcherTimer();
}

DispatcherTimer(DispatcherPriority) :-

This constructor holds a value of the DispatcherPriority Enumeration, which process the timer event at a specified priprity.

e.g.
System.Windows.Threading
class DispatcherTimerDemo
{
DispatcherTimer timer=new DispatcherTimer(DispatcherPriority.Normal);
}

DispatcherTimer(DispatcherPriority,Dispatcher) :-

It holds two parameter the former parameter specified the priority of the work, which is done by the the timer tick event.

e.g.
System.Windows.Threading
class DispatcherTimerDemo
{
DispatcherTimer timer=new DispatcherTimer(DispatcherPriority.Normal, Dispatcher.CurrentDispatcher);
}

DispatcherTimer(TimeSpan,DispatcherPriority,EventHandler,Dispatcher) :-

Specified the time interval, priority of the work, the work which is done when the tick event occur and the specified dispatcher.

e.g.
System.Windows.Threading
class DispatcherTimerDemo
{
DispatcherTimer timer=new DispatcherTimer(new TimeSpan(0,0,1),DispatcherPriority.Normal,new EventHandler(dispatcherTimer_Tick), Dispatcher.CurrentDispatcher);
}

Let's understad the DispatcherTimer, the picture helps you:-

Complete Example:-

Using System.Windows.Threading
namespace DispatcherTimerDemo
{
///

/// Interaction logic for Window1.xaml
///

public partial class Window1 : Window
{
int minute = 0;

public Window1()
{
InitializeComponent();
}

private void Window_Loaded(object sender, RoutedEventArgs e)
{
DispatcherTimer time = new DispatcherTimer(new TimeSpan(0, 0, 1), DispatcherPriority.Normal, new EventHandler(time_Tick), Dispatcher.CurrentDispatcher);
time.Tick += new EventHandler(time_Tick);
time.Start();
minute = DateTime.Now.Minute;

}

void time_Tick(object sender, EventArgs e)
{
lblTime.Content = DateTime.Now.ToLongTimeString();

int mnt = DateTime.Now.Minute;
if (mnt - minute == 1)
{
DoWork()//This function at an interval of One minute.

minute = DateTime.Now.Minute;
}
}

}

}

Note:- The above code is written in the WPF Application using c#.

Dispatcher

2008-07-30T19:58:00.000+05:30

Dispatcher is a sealed class which provides services for managing the queue of work items for a thread. The Dispatcher maintains a prioritized queue of work items for a specific thread.

If a Dispatcher is shut down, it cannot be restarted. It is mainly used for implementing the multi threading in WPF application.
Dispatcher class is available in the

System.Windows.Threading namespace

Inter Process Communication using Pipe.

2008-07-30T19:18:00.000+05:30

There are different types of way through which we implement the Inter Process Communication.

What is IPC?
IPC stands for Inter Process Communication. It means that two process communicate between them. We implement the IPC in .Net using the following ways:-

1. Shared Memory
2. Remoting
3. Mapped memory
4. Socket
5. Pipe

The pipe is the new way for implementing the IPC in .net 3.5. Before .net 3.5. we implement the Pipe by using the Microsoft.Win32 Namespace. But in .Net 3.5 the pipe is available under the System.IO.Pipe namespace. To implement the IPC using pipe we use two class from the System.IO.Pipe namespace.

1. NamedPipeServerStream
2.NamedPipeClienStream.

The programm which create the pipe is called the pipe server, and the programm which listen the programm is called the pipe client.

constructor For crating the Pipe server.

using System.IO.Pipe

class pipeServer
{
public pipeServer()
{
NamedPipeServerStream pipeServerStream=new NamedPipeServerStream("pipeServerMessaging",PipeDirection.In);

pipeServerStream.WaitForConnection();
}
}

Note:- In the above code NamedPipeServerStream is a class which creates the Pipe server, pipeServerStream is the object of the NamedPipeServerStream, the string written in double quote "pipeServerMessaging" is the name of the pipe, and PipeDirection is the enumeration which show the direction of the pipe.

After instantiating the pipeServerStream object, it wait for the connection.
Save it with .cs extension like other programs are saved in c#.

Now, create the pipe client
To create the pipe client we use the NamedPipeClientStream which are available in the System.IO.Pipe namespace

code for creating the pipe client

using System.IO.Pipe
class pipeClient
{
public pipeClient()
{
NamedPipeClientStream pipeClientStream=new NamedPipeClientStream("localhost","pipeServerMessaging", PipeDirection.Out);
pipeClient.Connect();
Console.WriteLine("Client Connected to the Server");
}

}

Note:- The following points keeps in mind when we create a pipe client

1. NamedPipeClientStream Constructor takes at least three argument.

A) Name of the computer on which your pipe server is running, if it is running on the local computer or on the same computer we pass the name of the computer "localhost" or "." . If the pipe server is running on the remote computer we pass the IP address of the remote computer or the name of the remote computer.

B) The second argument is the name of the pipe which is same as the pipe server.

C) The last argument is the pipe direction , which may be three value form the PipeDirection enumeration

Value of the PipeDirection

PipeDirection.In
PipeDirection.Out
PipeDirection.InOut

Caution:-
Save it with pipeClient.cs
Run the PipeServer programm first and the pipeClient.

This is the simple pipe demo for IPC