DotNet Experts

Drag-and-Drop Operation in Windows Forms

2014-04-14T11:15:00.002-07:00

Drag-and-Drop Operation in Windows Forms

To perform drag-and-drop operations within Windows-based applications you must handle a series of events, most notably the DragEnter, DragLeave, and DragDrop events. By working with the information available in the event arguments of these events, you can easily facilitate drag-and-drop operations.

To Start The Drag Operation

All drag-and-drop operations begin with dragging. The functionality to enable data to be collected when dragging begins is implemented in the DoDragDrop method.

In the following example, the MouseDown event is used to start the drag operation because it is the most intuitive (most drag-and-drop actions begin with the mouse button being depressed). However, remember that any event could be used to initiate a drag-and-drop procedure.

In the MouseDown event for the control where the drag will begin, use the DoDragDrop method to set the data to be dragged and the allowed effect dragging will have. For more information, see Data and AllowedEffect.
The following example shows how to initiate a drag operation. The control where the drag begins is a Button control, the data being dragged is the string representing the Text property of the Button control, and the allowed effects are either copying or moving.

private void button1_MouseDown(object sender, 
System.Windows.Forms.MouseEventArgs e)
{
   button1.DoDragDrop(button1.Text, DragDropEffects.Copy | 
      DragDropEffects.Move);
}


To perform a drop



Once you have begun dragging data from a location on a Windows Form or control, you will naturally want to drop it somewhere. The cursor will change when it crosses an area of a form or control that is correctly configured for dropping data. Any area within a Windows Form or control can be made to accept dropped data by setting the AllowDrop property and handling the DragEnter and DragDrop events.






Set the AllowDrop property to true.


In the DragEnter event for the control where the drop will occur, ensure that the data being dragged is of an acceptable type (in this case, Text). The code then sets the effect that will happen when the drop occurs to a value in the DragDropEffects enumeration. 







private void textBox1_DragEnter(object sender, 
System.Windows.Forms.DragEventArgs e)
{
   if (e.Data.GetDataPresent(DataFormats.Text)) 
      e.Effect = DragDropEffects.Copy;
   else
      e.Effect = DragDropEffects.None;
}

In the DragDrop event for the control where the drop will occur, use the GetData method to retrieve the data being dragged.

In the example below, a TextBox control is the control being dragged to (where the drop will occur). The code sets the Text property of the TextBox control equal to the data being dragged.
private void textBox1_DragDrop(object sender, 
System.Windows.Forms.DragEventArgs e)
{
   textBox1.Text = e.Data.GetData(DataFormats.Text).ToString();
}

The Concept Of Generics In .Net With C# And VB.Net

2014-04-12T13:08:00.000-07:00

The Detailed Description Of Generics In .Net

Generic Type : A generic type is a type that uses generic type parameters. For example, the type LinkedList, defined as:

public class LinkedList
{...}

VB.Net

Public Class LinkedList(Of K, T)
    ...
End Class

Generic Type Parameter : A generic type parameter is the place holder a generic type uses. For example, the generic type LinkedList, defined as:

C#

public class LinkedList
{...}
VB.Net
Public Class LinkedList(Of K, T)
    ...
End Class

Some more description about generics:

Constructed Type : A constructed type is any generic type that has at least one type argument.

Open Constructed Type : A open constructed type is any generic type that which contains at least one type parameter used as a type argument

Closed Constructed Type : A closed constructed type is a generic type that which contains no type parameters as type arguments.





Initialize a Generic Type Parameter

When declaring a generic type, you need to specify the types that will replace the type parameters in the declaration. These are known as type arguments to the generic type. Type arguments are simply types. 

You need to specify which types to use for K, the list's key, and T, the data items stored in the list. You specify the types in two places: when declaring the list's variable and when instantiating it:




C#

LinkedList list = new LinkedList();
list.AddHead(123,"ABC");
VB.Net
Dim list As New LinkedList(Of Integer, String)
list.AddHead(123, "ABC")


Constraints in Generics:


Constraints allow additional contextual information to be added to the type parameters of generic types. The constraints limit the range of types that are allowed to be used as type arguments, but at the same time, they add information about those type parameters. Constraints ensure that the type arguments specified by the client code are compatible with the generic type parameters the generic type itself uses. Meaning, constraints prevent the client from specifying types as type arguments that do not offer the methods, properties, or members of the generic type parameters that the generic type relies upon.

After applying a constraint you get IntelliSense reflecting the constraints when using the generic type parameter, such as suggesting methods or members from the base type.

Derivation constraint indicates to the compiler that the generic type parameters derives from a base type such an interface or a particular base class. 

You can provide constraints for every generic type parameter that your class declares. You can have a base class constraint, meaning, stipulating that the generic type parameter derives from a particular base class:

However, you can only use one base class at most in a constraint because neither C#, Visual Basic or managed C++ support multiple inheritance of implementation. Obviously, the base class you constrain to cannot be a sealed class, and the compiler enforces that. In addition, you cannot constrain System.Delegate or System.Array as a base class.

You can constrain both a base class and one or more interfaces, but the base class must appear first in the derivation constraint list.You can combine the default constructor constraint with derivation constraints, provided the default constructor constraint appears last in the constraint list.

Auto-Generate Wrapper Classes for Stored Procedures Using the AutoSproc Tool

2014-04-12T12:43:00.000-07:00

Auto-Generate Wrapper Classes for Stored Procedures Using the AutoSproc Tool

The essence of the idea behind AutoSproc is for the developer to define methods on an interface that correspond to the stored procedures that exist in a database. These interface methods are abstract at the time of program compilation, but receive an implementation at runtime from a code generation assembly the client program references, named AutoSproc.dll. At the heart of this assembly there is a publicly callable static (shared) method called SprocFactory.CreateInstance(). A key parameter that must be passed when making a call to this method is type information for an interface. The primary function of this method is to dynamically fabricate a class that implements the designated interface and to return an instance of that class to the caller. As an example, consider the following stored procedure definition:

CREATE PROCEDURE upAddTwoNumbers
@a int,
@b int,
@result int output
AS
select @result = @a+@b

Given this definition, the interface would be defined in Visual Basic .NET as follows:

Public Interface IMath
    Inherits ISprocBase
    Function upAddTwoNumbers(ByVal a As Integer, _
      ByVal b As Integer, _
      ByRef result As Integer) As Integer
End Interface


ISprocBase adds three properties to your deriving interface:
Public Interface ISprocBase
   Property Connection() as IDbConnection
   Property AutoClose () as Boolean
   Property Transaction () as IDbTransaction
End Interface
The Connection property is the means by which one passes the database connection to the code generated class at runtime.

ISprocBase.AutoClose Property

The AutoClose property on the interface can be used to toggle this feature on and off dynamically at runtime during the lifetime of the application.




ISprocBase.Transaction Property





It is often the case that a local transaction is used to protect multiple operations carried out against a database. To facilitate this, a transaction property is defined on the base interface. Its usage is fairly straightforward: Use the database connection to begin the transaction (IDbConnection.BeginTransaction()), feed the transaction to the transaction property on the code generated class, make one or more transacted stored procedure calls then either commit / abort or rollback the transaction (IDbTransaction.Commit()/ Abort() / Rollback()).

It is important to note that if AutoClose is set to true, then the transaction will exhibit potentially undesirable auto commit behavior because closing the database connection implicitly attempts to commit the transaction. It is recommended that if the Transaction property is being used then AutoClose is set to false.




SprocFactory.CreateInstance() Method Overloads

There are four overloaded SprocFactory.CreateInstance() methods offered, only one of which is strictly necessary (the second one). The other three are offered as a convenience to the developer for seeding Connection and AutoClose properties at creation time. It should be noted that overloads not providing an AutoClose parameter (the first and third) will configure it to true by default.







Public Shared Function CreateInstance (ByVal itf as Type, _
ByVal prov as DBProvider) _
as Object


2.
Public Shared Function CreateInstance (ByVal itf as Type, _
ByVal prov as DBProvider, _
                  autoClose as Boolean) as Object 
3
Public Shared Function CreateInstance (ByVal itf as Type, _
ByVal conn as IDbConnection) _
as Object
4.
Public Shared Function CreateInstance (ByVal itf as Type, _
ByVal conn as IDbConnection, _
                  ByVal autoClose as Boolean) _
                  as Object
The DBProvider enumeration is the means by which the user configures the code generation layer to emit an implementation. For this release, only SQL Server and OleDb managed providers are available. If the user elects to use the third or fourth CreateInstance() method then the database provider type is inferred by the code generation layer from the IDbConnection parameter, thus making a DBProvider enumeration parameter unnecessary.

Drawing in .Net With GDI+

2014-03-30T10:04:00.001-07:00

Drawing in .Net With GDI+

GDI+ is an application programming interface (API) that forms the subsystem of the Microsoft Windows XP operating system. GDI+ is responsible for displaying information on screens and printers. As its name suggests, GDI+ is the successor to GDI, the Graphics Device Interface included with earlier versions of Windows.

The GDI+ API is exposed through a set of classes deployed as managed code. This set of classes is called the managed class interface to GDI+. The following namespaces make up the managed class interface:

System.Drawing:

The Graphics class provides methods for drawing to the display device. Classes such as Rectangle and Point encapsulate GDI+ primitives. The Pen class is used to draw lines and curves, while classes derived from the abstract class Brush are used to fill the interiors of shapes.

Classes

Bitmap:Encapsulates a GDI+ bitmap, which consists of the pixel data for a graphics image and its attributes. A Bitmap is an object used to work with images defined by pixel data.
Brush:Defines objects used to fill the interiors of graphical shapes such as rectangles, ellipses, pies, polygons, and paths.
Brushes:Brushes for all the standard colors. This class cannot be inherited.
BufferedGraphics:Provides a graphics buffer for double buffering.
BufferedGraphicsContext: Provides methods for creating graphics buffers that can be used for double buffering.
ColorConverter: Converts colors from one data type to another. Access this class through the TypeDescriptor.
ColorTranslator : Translates colors to and from GDI+ Color structures. This class cannot be inherited.
Font : Defines a particular format for text, including font face, size, and style attributes. This class cannot be inherited.
FontConverter : Converts Font objects from one data type to another.
FontConverter.FontNameConverter : Infrastructure. FontConverter.FontNameConverter is a type converter that is used to convert a font name to and from various other representations.
FontConverter.FontUnitConverter : Infrastructure. Converts font units to and from other unit types.
FontFamily : Defines a group of type faces having a similar basic design and certain variations in styles. This class cannot be inherited.
Graphics : Encapsulates a GDI+ drawing surface. This class cannot be inherited.
Icon : Represents a Windows icon, which is a small bitmap image used to represent an object. Icons can be thought of as transparent bitmaps, although their size is determined by the system.
IconConverter : Converts an Icon object from one data type to another. Access this class through the TypeDescriptor object.
Image : An abstract base class that provides functionality for the Bitmap and Metafile descended classes.
ImageAnimator : Animates an image that has time-based frames.
ImageConverter: ImageConverter is a class that can be used to convert Image objects from one data type to another. Access this class through the TypeDescriptor object.
ImageFormatConverter : ImageFormatConverter is a class that can be used to convert ImageFormat objects from one data type to another. Access this class through the TypeDescriptor object.
Pen: Defines an object used to draw lines and curves. This class cannot be inherited.
Pens : Pens for all the standard colors. This class cannot be inherited.
PointConverter : Converts a Point object from one data type to another. Access this class through the TypeDescriptor object.
PointConverter :Converts a Point object from one data type to another. Access this class through the TypeDescriptor object.
RectangleConverter: Converts rectangles from one data type to another. Access this class through the TypeDescriptor.
Region :Describes the interior of a graphics shape composed of rectangles and paths. This class cannot be inherited.
SizeConverter : The SizeConverter class is used to convert from one data type to another. Access this class through theTypeDescriptor object.
SizeFConverter : Converts SizeF objects from one type to another.
SolidBrush : Defines a brush of a single color. Brushes are used to fill graphics shapes, such as rectangles, ellipses, pies, polygons, and paths. This class cannot be inherited.
StringFormat : Encapsulates text layout information (such as alignment, orientation and tab stops) display manipulations (such as ellipsis insertion and national digit substitution) and OpenType features. This class cannot be inherited.
SystemBrushes : Each property of the SystemBrushes class is a SolidBrush that is the color of a Windows display element.
SystemColors : Each property of the SystemColors class is a Color structure that is the color of a Windows display element.
SystemFonts : Specifies the fonts used to display text in Windows display elements.
SystemIcons : Each property of the SystemIcons class is an Icon object for Windows system-wide icons. This class cannot be inherited.
SystemPens : Each property of the SystemPens class is a Pen that is the color of a Windows display element and that has a width of 1 pixel.
TextureBrush :Each property of the TextureBrush class is a Brush object that uses an image to fill the interior of a shape. This class cannot be inherited.
ToolboxBitmapAttribute : Allows you to specify an icon to represent a control in a container, such as the Microsoft Visual Studio Form Designer.

Formating in DataGridView

2014-03-30T09:01:00.000-07:00

To Set Alternating Row Styles for the Windows Forms DataGridView Control

With the DataGridView control, you can specify complete style information for alternating rows. This enables you use style characteristics like foreground color and font, in addition to background color, to differentiate alternating rows.

this.dataGridView1.RowsDefaultCellStyle.BackColor = Color.Bisque;
this.dataGridView1.AlternatingRowsDefaultCellStyle.BackColor =
    Color.Beige;







To specify the font used by DataGridView cells



Set the Font property of a DataGridViewCellStyle



this.dataGridView1.DefaultCellStyle.Font = new Font("Verdana", 15);

To specify the foreground and background colors of DataGridView cells

Set the ForeColor and BackColor properties of a DataGridViewCellStyle.
this.dataGridView1.DefaultCellStyle.ForeColor = Color.Blue;
this.dataGridView1.DefaultCellStyle.BackColor = Color.Beige;

To specify the foreground and background colors of selected DataGridView cells


Set the SelectionForeColor and SelectionBackColor properties of a DataGridViewCellStyle.


this.dataGridView1.DefaultCellStyle.SelectionForeColor = Color.Yellow;
this.dataGridView1.DefaultCellStyle.SelectionBackColor = Color.Black;


Use the Row Template to Customize Rows in the Windows Forms DataGridView Control

The DataGridView control uses the row template as a basis for all rows that it adds to the control either through data binding or when you call theDataGridViewRowCollection.Add method without specifying an existing row to use.

The row template gives you greater control over the appearance and behavior of rows than the RowsDefaultCellStyle property provides. With the row template, you can set anyDataGridViewRow properties, including DefaultCellStyle.

There are some situations where you must use the row template to achieve a particular effect. For example, row height information cannot be stored in a DataGridViewCellStyle, so you must use a row template to change the default height used by all rows. The row template is also useful when you create your own classes derived from DataGridViewRow and you want your custom type used when new rows are added to the control.



Set properties on the object retrieved from the DataGridView.RowTemplate property.





DataGridViewRow row = this.dataGridView1.RowTemplate;
row.DefaultCellStyle.BackColor = Color.Bisque;
row.Height = 35;
row.MinimumHeight = 20;

Change the Border and Gridline Styles in the Windows Forms DataGridView Control

2014-03-30T08:37:00.001-07:00

To Change the Border and Gridline Styles in the Windows Forms DataGridView Control

With the DataGridView control, you can customize the appearance of the control's border and gridlines to improve the user experience. You can modify the gridline color and the control border style in addition to the border styles for the cells within the control. You can also apply different cell border styles for ordinary cells, row header cells, and column header cells.

To change the gridline color programmatically

Set the GridColor property.

this.dataGridView1.GridColor = Color.Blue;


To change the border style of the entire DataGridView control programmatically


Set the BorderStyle property to one of the BorderStyle enumeration values.



To change the border styles for DataGridView cells programmatically



Set the CellBorderStyle, RowHeadersBorderStyle, and ColumnHeadersBorderStyle properties.


this.dataGridView1.CellBorderStyle =
    DataGridViewCellBorderStyle.None;
this.dataGridView1.RowHeadersBorderStyle =
    DataGridViewHeaderBorderStyle.Single;
this.dataGridView1.ColumnHeadersBorderStyle =
    DataGridViewHeaderBorderStyle.Single;

Configure an Application to Support .NET Framework 4 or 4.5

2014-03-30T04:43:00.002-07:00

Application Configuration to Support .Net Framework 4 or 4.5

All apps that host the common language runtime (CLR) need to start, or activate, the CLR in order to run managed code. Typically, a .NET Framework app runs on the version of the CLR that it was built on, but you can change this behavior for desktop apps by using an application configuration file (sometimes referred to as an app.config file). However, you cannot change the default activation behavior for Windows Store apps or Windows Phone apps by using an application configuration file.

To configure your app to run on the .NET Framework 4 or 4.5

Add or locate the configuration file for the .NET Framework project. The configuration file for an app is in the same directory and has the same name as the app, but has a .config extension. For example, for an app named MyExecutable.exe, the application configuration file is named MyExecutable.exe.config.

To add a configuration file, on the Visual Studio menu bar, choose Project, Add New Item. Choose General from the left pane, and then choose Configuration File. Name the configuration file appName.exe.config. These menu choices are not available for Windows Store app or Windows phone app projects, because you cannot change the activation policy on those platforms.
Add the element as follows to the application configuration file:
```
  
    
  
```


where  specifies the CLR version that aligns with the .NET Framework version that your app supports. Use the following strings:


.NET Framework 1.0: "v1.0.3705"


.NET Framework 1.1: "v1.1.4322"


.NET Framework 2.0, 3.0, and 3.5: "v2.0.50727"


.NET Framework 4 and 4.5 (including point releases such as 4.5.1): "v4.0"



You can add multiple  elements, listed in order of preference, to specify support for multiple versions of the .NET Framework.

Introduction to Yield Statement in VB.Net

2014-03-29T20:04:00.000-07:00

The Yield Statement in VB.Net

The Yield statement returns one element of a collection at a time. The Yield statement is included in an iterator function or Get accessor, which perform custom iterations over a collection.

You consume an iterator function by using a For Each...Next Statement (Visual Basic) or a LINQ query. Each iteration of the For Each loop calls the iterator function. When aYield statement is reached in the iterator function, expression is returned, and the current location in code is retained. Execution is restarted from that location the next time that the iterator function is called.

An implicit conversion must exist from the type of expression in the Yield statement to the return type of the iterator.

You can use an Exit Function or Return statement to end the iteration.

"Yield" is not a reserved word and has special meaning only when it is used in an Iterator function or Get accessor.

Iterator Functions and Get Accessors

The declaration of an iterator function or Get accessor must meet the following requirements:

It must include an Iterator modifier.
The return type must be IEnumerable, IEnumerable<T>, IEnumerator, or IEnumerator<T>.
It cannot have any ByRef parameters.
An iterator function can be an anonymous function. For more information

An iterator function cannot occur in an event, instance constructor, static constructor, or static destructor.

Exception Handling in Yield

A Yield statement can be inside a Try block of a Try...Catch...Finally Statement (Visual Basic). A Try block that has a Yield statement can have Catch blocks, and can have aFinally block.

A Yield statement cannot be inside a Catch block or a Finally block.

If the For Each body (outside of the iterator function) throws an exception, a Catch block in the iterator function is not executed, but a Finally block in the iterator function is executed. A Catch block inside an iterator function catches only exceptions that occur inside the iterator function.

An Example:

Sub Main()
    For Each number In Power(2, 8)
        Console.Write(number & " ")
    Next 
    ' Output: 2 4 8 16 32 64 128 256
    Console.ReadKey()
End Sub 

Private Iterator Function Power(
ByVal base As Integer, ByVal highExponent As Integer) _
As System.Collections.Generic.IEnumerable(Of Integer)

    Dim result = 1

    For counter = 1 To highExponent
        result = result * base
        Yield result
    Next 
End Function

Introduction to SyncLock Statement in VB.Net

2014-03-29T19:53:00.002-07:00

The SyncLock statement in VB.Net

SyncLock in VB.Net

The SyncLock statement ensures that multiple threads do not execute the statement block at the same time. SyncLock prevents each thread from entering the block until no other thread is executing it.

The most common use of SyncLock is to protect data from being updated by more than one thread simultaneously. If the statements that manipulate the data must go to completion without interruption, put them inside a SyncLock block.

A statement block protected by an exclusive lock is sometimes called a critical section.

Branching. You cannot branch into a SyncLock block from outside the block.
Lock Object Value. The value of lockobject cannot be Nothing. You must create the lock object before you use it in a SyncLock statement.

You cannot change the value of lockobject while executing a SyncLock block. The mechanism requires that the lock object remain unchanged.
You can't use the Await operator in a SyncLock block.

How SyncLock Statement works in vb.net

Mechanism. When a thread reaches the SyncLock statement, it evaluates the lockobject expression and suspends execution until it acquires an exclusive lock on the object returned by the expression. When another thread reaches the SyncLock statement, it does not acquire a lock until the first thread executes the End SyncLockstatement.
Protected Data. If lockobject is a Shared variable, the exclusive lock prevents a thread in any instance of the class from executing the SyncLock block while any other thread is executing it. This protects data that is shared among all the instances.

If lockobject is an instance variable (not Shared), the lock prevents a thread running in the current instance from executing the SyncLock block at the same time as another thread in the same instance. This protects data maintained by the individual instance.
Acquisition and Release. A SyncLock block behaves like a Try...Finally construction in which the Try block acquires an exclusive lock on lockobject and the Finallyblock releases it. Because of this, the SyncLock block guarantees release of the lock, no matter how you exit the block. This is true even in the case of an unhandled exception.
Framework Calls. The SyncLock block acquires and releases the exclusive lock by calling the Enter and Exit methods of the Monitor class in the System.Threadingnamespace.

Example

The following example shows a class that maintains a simple list of messages. It holds the messages in an array and the last used element of that array in a variable. The addMessage procedure increments the last element and stores the new message. Those two operations are protected by the SyncLock and End SyncLockstatements, because once the last element has been incremented, the new message must be stored before any other thread can increment the last element again.

If the simpleMessageCollection class shared one list of messages among all its instances, the variables messageCollection and messageseEnd would be declared as Shared. In this case, the variable msgLock should also be Shared, so that there would be a single lock object used by every instance.

Class simpleMessageCollection
    Public messagesCollection() As String = New String(100) {}
    Public messagesEnd As Integer = -1
    Private msgLock As New Object 
    Public Sub addMessage(ByVal newMsg As String)
        SyncLock msgLock
            messagesEnd += 1
            If messagesEnd < messagesCollection.Length Then
                messagesCollection(messagesEnd) = newMsg
            End If 
        End SyncLock 
    End Sub 
End Class

The using Keyword/Statement in C# and VB.Net

2014-03-29T19:38:00.001-07:00

All About using Keyword/Statement in C# and VB.Net

In C#, using Keyword can be used in two different ways and are hence referred to differently.

As a Directive
In this usage, the "using" keyword can be used to include a namespace in your program.(Mostly used)

As a Statement
Using can also be used in a block of code to dispose a IDisposable objects.(less used).

Example

A simple and straightforward approach to connect to a database server and read data would be-

  SqlConnection sqlconnection = new SqlConnection(connectionString);
SqlDataReader reader = null;
SqlCommand cmd = new SqlCommand(commandString.  sqlconnection);
  sqlconnection .Open();
reader = cmd.ExecuteReader();
       while (reader.Read())
         {
           //Do
         }
reader.Close();
  sqlconnection .Close();

However, the above given code may generate error.

If any exception occurs inside while block it throws exception the connection.close() process will not executed due to the exception.To avoid this situation, we can take the help of the try....catch... finally block by closing the connection inside the finally block or inside the catch block.

"Using" keyword takes the parameter of type IDisposable.Whenever you are using any IDisposable type object you should use the "using" keyword to handle automatically when it should close or dispose. Internally using keyword calls the Dispose() method to dispose the IDisposable object.

So the correct code would be :

using(SqlConnection sqlconnection= new SqlConnection(connectionString) )
            {
              SqlCommand cmd = new SqlCommand(commandString, sqlconnection);
          sqlconnection.Open();
             using (SqlDataReader reader = cmd.ExecuteReader())
             {
                while (reader.Read())
                {
                  //DO
                }
             }
           }

In this code if any exception occurs then dispose() will be called and connection will closed automatically.

Using Statement in VB.Net

Sometimes your code requires an unmanaged resource, such as a file handle, a COM wrapper, or a SQL connection. A Using block guarantees the disposal of one or more such resources when your code is finished with them. This makes them available for other code to use.

Managed resources are disposed of by the .NET Framework garbage collector (GC) without any extra coding on your part. You do not need a Using block for managed resources. However, you can still use a Using block to force the disposal of a managed resource instead of waiting for the garbage collector.

A Using block has three parts: acquisition, usage, and disposal.

Acquisition means creating a variable and initializing it to refer to the system resource. The Using statement can acquire one or more resources, or you can acquire exactly one resource before entering the block and supply it to the Using statement. If you supply resourceexpression, you must acquire the resource before passing control to the Using statement.
Usage means accessing the resources and performing actions with them. The statements between Using and End Using represent the usage of the resources.
Disposal means calling the Dispose method on the object in resourcename. This allows the object to cleanly terminate its resources. The End Using statement disposes of the resources under the Using block's control.

How using statement works in VB.Net

A Using block behaves like a Try...Finally construction in which the Try block uses the resources and the Finally block disposes of them. Because of this, the Using block guarantees disposal of the resources, no matter how you exit the block. This is true even in the case of an unhandled exception, except for a StackOverflowException.

The scope of every resource variable acquired by the Using statement is limited to the Using block.

If you specify more than one system resource in the Using statement, the effect is the same as if you nested Using blocks one within another.

If resourcename is Nothing, no call to Dispose is made, and no exception is thrown.

Example

The following example creates a file that is named log.txt and writes two lines of text to the file. The example also reads that same file and displays the lines of text.

Because the TextWriter and TextReader classes implement the IDisposable interface, the code can use Using statements to ensure that the file is correctly closed after the write and read operations.

Private Sub WriteToFile()
    Using writer As System.IO.TextWriter = System.IO.File.CreateText("myfile.txt")
        writer.WriteLine("This is line one.")
        writer.WriteLine("This is line two.")
    End Using 
End Sub 

Private Sub ReadFromFile()
    Using reader As System.IO.TextReader = System.IO.File.OpenText("log.txt")
        Dim line As String

        line = reader.ReadLine()
        Do Until line Is Nothing
            Console.WriteLine(line)
            line = reader.ReadLine()
        Loop 
    End Using 
End Sub

C# Programming Fundamentals

2014-03-27T09:12:00.000-07:00

C# Programming Fundamentals in Point wise Way

A complete program instruction is called a statement. Each statement ends with a semicolon (;).
All objects, variables, and constants must have a specific type.
Most of the intrinsic types are used for working with numeric values. You will commonly use int for whole numbers and double or float for fractional values.
The char type is used for holding a single character.
The bool type can hold only the value true or false.
A variable is an instance of a type. You initialize a variable by creating it with an assigned value.
You can use the var keyword to create a variable without a type, but only if you assign it immediately. The complier will determine the type of the variable from the value assigned.
You can cast a value from one type to another as long as the compiler knows how to turn the original type into the cast-to type. If no information can be lost, you may cast from one type to another implicitly. If information may be lost, you must cast explicitly. You accomplish the cast by prefacing the variable with the name of the type you want to cast to, in parentheses.
A constant is similar to a variable, but the value cannot be changed while the program is running. Literal constants are simply values used on their own. Symbolic constants, indicated with the const keyword, are values with assigned names, which you use like variables, but the values cannot change.
An enumeration is a value type that consists of a set of named constants.
A string object holds a series of characters (such as a word or sentence). A string literal is simply text enclosed by double quotes. You can assign a string to a string variable, just as you would make any other assignment.
Extra whitespace (spaces, tabs, and newline characters) is ignored by the compiler, unless it appears within a string.

Introduction To The is and as Operator in C#

2014-03-27T09:06:00.000-07:00

The is and as Operator in C#

Sometimes, however, you may not know at compile time whether an object supports a particular interface.

The is operator lets us query whether an object implements an interface (or derives from a base class). The form of the is operator is:

if ( expression is type )


The is operator evaluates true if the expression (which must be a reference type, such as an instance of a class) can be safely cast to type without throwing an exception.

The as operator is similar to is, but it goes a step further. The as operator tries to cast the object to the type, and if an exception would be thrown, it instead returns null:
ICompressible myCompressible = myObject as ICompressible
if ( myCompressible != null )
The is operator is slightly less efficient than using as, so the as operator is slightly preferred over the is operator, except when you want to do the test but not actually do the cast (a rare situation).

A Brief Intoduction To ADO.Net

2014-03-27T08:50:00.001-07:00

Here is the list of some basic points that will help you to understand ADO.Net and keep in mind about the basic features of ADO.Net

ADO.NET provides classes that allow you to retrieve and manipulate data from databases for use in your code.
ADO.NET was designed to use a disconnected data architecture, meaning that information is retrieved and stored locally, to diminish use of resource-intensive database connections.
A database is a structured repository of information, and a relational database is a database that organizes the data into tables.
The tables in relational databases are further divided into rows, where each row represents a single record, and columns, which represent categories of data.
The primary key in a table is a column containing values that are unique for each record in that table.
A foreign key is a column that serves as the primary key for a different table, and helps to create one-to-many relationships among data in separate tables.
Normalization is the process of removing redundant information from records into separate tables, which reduces complexity and speeds up the retrieval process.
Constraints set limitations on data to avoid data conflicts and errors.
SQL is a language commonly used to access and manipulate databases. The fundamental operation in SQL is the query.
Defining filters with a query allows you to retrieve specific subsets of information.
Using a join in a query allows you to retrieve data based on membership in more than one table.
The DataSet object represents a subset of data retrieved from the database.
The DataSet object contains a collection called Tables, which in turn contains DataTable objects.
The DataTable object contains a collection called Columns, which contains DataColumn objects, and a collection called Rows, which contains DataRow objects.
The Rows collection allows you to examine the results of your query, usually by iterating over the collection with a loop.
The DataAdapter is a class that forms a bridge between the database and the DataSet class, using a connection string and a query string. The DataAdapter can then be used to populate the DataSet object using the Fill( ) method.

Async Programming In C#

2014-03-25T10:45:00.001-07:00

An Introduction to Async Programming In C#

The Async feature in Visual Studio 2012 RC makes it easy to invoke asynchronous methods.If a method marked with or async modifier, we can use the await operator in the method. When control reaches an await expression in the async method, control returns to the caller, and progress in the method is suspended until the awaited task completes. When the task is complete, execution can resume in the method.

Using asynchronous methods instead of synchronous methods can provide benefits. Asynchrony makes UI applications more responsive because the UI thread that launches that operation can perform other work. Asynchrony also improves the scalability of server-based application by reducing the need for threads.

What's the difference between asynchronous programming and using multiple threads to do parallel programming?
In synchronous programming, something doesn't happen until the last thing is done. There may not be any human delays for which Async may be useful, but there are much shorter delays. Think milliseconds. These often are I/O operations like waiting to retrieve something from the hard drive. There are a lot of short delays, so the milliseconds add up to mega-milliseconds, so people watch swirling donuts.

Using multiple threads and the Task Parallel Library can improve things. On a single core processor, while one thread is waiting to get something back from the hard drive, Windows may assign another thread to run on the processor. That makes the whole thing run faster. On multiple core processors, things are even better. Windows may assign one thread to run on one core, and another to run on another.

Play All/Any Video Formats Including MKV,MP4,AVI,h264,BluRay DVD,MOV,WMV,DIVX,WebM etc.. With FFDShow

2014-03-23T04:04:00.001-07:00

To Play All Video Formats MKV,AVI,DIVX,H642,WebM,Mov,BluRay DVD,MP4,MPEG1,MPEG2,WMV or any other video format on Windows XP/Windows Vista/Wndows 7/Windows 8 Without any codec pack.

There are many codec packs available like K-Lite,Combined Community Codec pack,Shark 007 Codec Pack but These codec packs take little bits of standalone decoders and chop them into their own application making them very difficult to know what you have installed and can create conflicts if set up incorrectly.
So we can setup our Own way to play video file using FFDshow.

Why FFDShow

We can manage our decoders and splitters manually and update them ourrself as updates become available without bre yaking your setup or having to go thru setting it up again. With Shark007 and CCCP you have to wait for the authors to release updates to continue using their packs if new features are released.
FFDShow caters for “all” codecs required by any modern HTPC setup (video/audio/subtitles) and also offers some great post processing filters in order to improve on image quality and sound quality.
By installing only one decoder (FFDShow) you eliminate decoder conflicts which makes finding the root cause of a problem much easier to find. (Shark007 uses many different decoders, haali is not updated enough and doesn’t support subtitles in Win7)
FFDShow using the Matroskasplitter allows for flawless playback of HD audio bitstreaming in MKV’s (providing your hardware allows this), which as we all know play natively in MediaBrowser (unlike .ts, .m2ts files ripped from BD discs)

What is FFDShow???

FFDShow is an excellent Decoder for Video formats, Audio formats and now incorporates DXVA 1.0 & 2.0 (Hardware Acceleration) decoding for h264 & VC-1 formats and copes with subtitles in WMP & MCE.

3 Items are required to be installed in order to get almost all formats working on your HTPC flawlessly. Also the requirement to install the “Preferred FilterTweaker Tool”. This allows you to set up your decoder preferences to override Windows 7 Media Foundation.

What we aim to do in this guide is to help setup what you might need to get your codecs working right, add post processing filters, resizing your movies to fill your screen. Also how to turn any 2.0 mp3 audio stream into full Dolby Digital 5.1 (AC3) output.

Which Things are Needed?

Firstly We will need to download and register Some filters. The first being MP4Splitter (this allows native playing of Apple’s movie formats natively) and the second is the MatroskaSplitter (this is a much better MKV splitter than Haali and is constantly being improved on to work with FFDShow). To Play Flash Video .FLV File Smoothly We need FLVSplitter.

Now The Step Goes To Download And Installation:

For 32 Bit System Download This:

https://onedrive.live.com/redir?resid=5B4625859B3D192F!131&authkey=!AE6VRFwH5QClGPE&ithint=file%2c.rar

For 64 Bit System Download This:

https://onedrive.live.com/redir?resid=5B4625859B3D192F%21132

Now We have to register these filters Using regsv32 Command

First thing to note here is:

Disable The UAC Before Registering these filters.

Download the latest FFDShow SVN Build From SourceFourge.Com.

http://sourceforge.net/projects/ffdshow-tryout/files/latest/download?source=directory

After download install ffdshow.

Now its time to configure the FFDShow Video And FFDShow Audio Decoder to do all the tasks:

configure FFDShow Video Decoder:

Select Video Decoder Configuration in start Menu ffdshow Folder:

Select Codecs tab in left panel then right click any where on the grid showing formats decoder
and then select Set all stable formats to libavcodec
this will enable all supported formats to libavcodec but for VP8,MPEG1,MPEG2,WMV and VC1 we have to enable it accordinglly like below:

Re-size The Video

resize is usefull when coupled with postprocessing filter we can resize and set the proper aspect ratio of our videos by using this property:

Post Processing Filter Setting:

Check Automatic Quality Control , Also option for Apply Process whole image or only right half.

Setting of Win7DsFilterTweaker

After doing these settings we need to Configure to disable the Microsoft Video Decoder for this
we can use Win7DSFilterTweaker Tool.

First to associate the video formats to ffdshow video decoder Click On Prefered decoders in aboove shown screen:

Then its time to disable windows audio and video decoders:

Now Disable The DMO

After doing these settings now we can play any video format on our system.

LINQ Query Expressions in C#

2014-03-22T11:54:00.001-07:00

LINQ Query Expressions in C#

Language-Integrated Query (LINQ) is the name for a set of technologies based on the integration of query capabilities directly into the C# language (also in Visual Basic and potentially any other .NET language). With LINQ, a query is now a first-class language construct, just like classes, methods, events and so on.

For a developer who writes queries, the most visible "language-integrated" part of LINQ is the query expression. Query expressions are written in a declarative query syntaxintroduced in C# 3.0. By using query syntax, you can perform even complex filtering, ordering, and grouping operations on data sources with a minimum of code. You use the same basic query expression patterns to query and transform data in SQL databases, ADO.NET Datasets, XML documents and streams, and .NET collections.

class MYLINQQueryExpressions
{
    static void Main()
    {

        // Specify the data source. 
        int[] marks= new int[] { 77, 110, 92, 125};

        // Define the query expression.
        IEnumerable<int> scoreQuery =
            from mark in marks
            where mark> 95
            select mark;

        // Execute the query. 
        foreach (int i in scoreQuery)
        {
            Console.Write(i + " ");
        }            
    }
}
// Output: 110 125

How to Write LINQ Query Expressions

Guidelines to write LINQ Query Expressions

Query expressions can be used to query and to transform data from any LINQ-enabled data source. For example, a single query can retrieve data from a SQL database, and produce an XML stream as output.
Query expressions are easy to master because they use many familiar C# language constructs.
The variables in a query expression are all strongly typed, although in many cases you do not have to provide the type explicitly because the compiler can infer it.
A query is not executed until you iterate over the query variable in a foreach statement.
At compile time, query expressions are converted to Standard Query Operator method calls according to the rules set forth in the C# specification. Any query that can be expressed by using query syntax can also be expressed by using method syntax. However, in most cases query syntax is more readable and concise.
As a rule when you write LINQ queries, we recommend that you use query syntax whenever possible and method syntax whenever necessary. There is no semantic or performance difference between the two different forms. Query expressions are often more readable than equivalent expressions written in method syntax.
Some query operations, such as Count or Max, have no equivalent query expression clause and must therefore be expressed as a method call. Method syntax can be combined with query syntax in various ways.
Query expressions can be compiled to expression trees or to delegates, depending on the type that the query is applied to. IEnumerable<T> queries are compiled to delegates. IQueryable and IQueryable<T> queries are compiled to expression trees.

How to identify a computer that do not have .net framework

2014-03-21T20:32:00.000-07:00

To Identify a computer that do not have .Net Framework:

1. In the configuration manager navigate to System Center Configuration Manager/Site Database/System Status/Status Message Query.

2. Right Click on All Status Message and Click On Show Messages.

3. In the All Status Messages dialog box enter the time period or date and time for which you want to check the status messages and then click OK.

4. All Status Messages are displayed in Status Message Viewer , click on the Component column and locate the status messages with a component named Desired Configuration Management.

5. In The Message ID column , look for 11802 to identify the computer that logged to this message.

6. For more information to this message Right Click a status message and select Detail.

7.View the information in Status Message Details dialog box and then clock OK to close this dialog box or clock previous or next to view the details of other messages.

8. Click OK to close Status Message Details dialog box and close the Status Message Viewer.

A Sample Client/Server Chat Program in C#

2014-03-21T20:01:00.000-07:00

How to make a sample client/server chat program in C# .Net

This is the sample code for client part of chat program.
Client

using System.IO;
using System.Net;
using System;
using System.Threading;
using N = System.Net;
using System.Collections;
using System.Windows.Forms;
using System.ComponentModel;
using System.Runtime.InteropServices;

class TalkUser {

static Form talk;
static N.Sockets.TcpClient TC;

[DllImport("kernel32.dll")]
private static extern void ExitProcess(int a);

public static void Main() {
talk = new Form();
talk.Text = "TalkUser - The OFFICIAL TalkServ Client";
talk.Closing += new CancelEventHandler(talk_Closing);
talk.Controls.Add(new TextBox());
talk.Controls[0].Dock = DockStyle.Fill;
talk.Controls.Add(new TextBox());
talk.Controls[1].Dock = DockStyle.Bottom;
((TextBox)talk.Controls[0]).Multiline = true;
((TextBox)talk.Controls[1]).Multiline = true;
talk.WindowState = FormWindowState.Maximized;
talk.Show();
((TextBox)talk.Controls[1]).KeyUp += new KeyEventHandler(key_up);
TC = new N.Sockets.TcpClient();
TC.Connect("IP OF A SERVER HERE",4296);
Thread t = new Thread(new ThreadStart(run));
t.Start();
while(true) {
Application.DoEvents();
}
}

private static void talk_Closing(object s, CancelEventArgs e) {
e.Cancel = false;
Application.Exit();
ExitProcess(0);
}

private static void key_up(object s,KeyEventArgs e) {
TextBox TB = (TextBox)s;
if(TB.Lines.Length>1) {
StreamWriter SW = new StreamWriter(TC.GetStream());
SW.WriteLine(TB.Text);
SW.Flush();
TB.Text = "";
TB.Lines = null;
}
}

private static void run() {
StreamReader SR = new StreamReader(TC.GetStream());
while(true) {
Application.DoEvents();
TextBox TB = (TextBox)talk.Controls[0];
TB.AppendText(SR.ReadLine()+"\r\n");
TB.SelectionStart = TB.Text.Length;
}
}
}

This is server part of chat program.

using System.IO;
using System.Net;
using System;
using System.Threading;
using N = System.Net;
using System.Collections;

class TalkServ {

System.Net.Sockets.TcpListener server;
public static Hashtable handles;
public static Hashtable handleByConnect;

public static void Main() {
TalkServ TS = new TalkServ();
}

public TalkServ() {
handles = new Hashtable(100);
handleByConnect = new Hashtable(100);
server = new System.Net.Sockets.TcpListener(4296);
while(true) {
server.Start();
if(server.Pending()) {
N.Sockets.TcpClient connection = server.AcceptTcpClient();
Console.WriteLine("Connection made");
BackForth BF = new BackForth(connection);
}
}
}

public static void SendToAll(string name,string msg) {
StreamWriter SW;
ArrayList ToRemove = new ArrayList(0);
N.Sockets.TcpClient[] tc = new N.Sockets.TcpClient[TalkServ.handles.Count];
TalkServ.handles.Values.CopyTo(tc,0);
for(int i=0;i
try {
if(msg.Trim()==""||tc[i]==null)
continue;
SW = new StreamWriter(tc[i].GetStream());
SW.WriteLine(name + ": " + msg);
SW.Flush();
SW = null;
} catch(Exception e44) { e44 = e44;
string g = (string) TalkServ.handleByConnect[tc[i]];
TalkServ.SendSysMsg("** " + g + " ** HAS LEFT US.");
TalkServ.handles.Remove(g);
TalkServ.handleByConnect.Remove(tc[i]);
}
}
}

public static void SendSysMsg(string msg) {
StreamWriter SW;
ArrayList ToRemove = new ArrayList(0);
N.Sockets.TcpClient[] tc = new N.Sockets.TcpClient[TalkServ.handles.Count];
TalkServ.handles.Values.CopyTo(tc,0);
for(int i=0;i
try {
if(msg.Trim()==""||tc[i]==null)
continue;
SW = new StreamWriter(tc[i].GetStream());
SW.WriteLine(msg);
SW.Flush();
SW = null;
} catch(Exception e44) { e44 = e44;
TalkServ.handles.Remove(TalkServ.handleByConnect[tc[i]]);
TalkServ.handleByConnect.Remove(tc[i]);
}
}
}
}//end of class TalkServ

class BackForth {
N.Sockets.TcpClient client;
System.IO.StreamReader SR;
System.IO.StreamWriter SW;
string handle;

public BackForth(System.Net.Sockets.TcpClient c) {
client = c;
Thread t = new Thread(new ThreadStart(init));
t.Start();
}

private string GetHandle() {
SW.WriteLine("What is your handle? ");
SW.Flush();
return SR.ReadLine();
}

private void run() {
try {
string l = "";
while(true) {
l = SR.ReadLine();
TalkServ.SendToAll(handle,l);
}
} catch(Exception e44) { Console.WriteLine(e44); }
}

private void init() {
SR = new System.IO.StreamReader(client.GetStream());
SW = new System.IO.StreamWriter(client.GetStream());
SW.WriteLine("WELCOME TO TalkServ! Be Nice!");
//SW.WriteLine("What is your handle? ");
//SW.Flush();
handle = GetHandle();
while(TalkServ.handles.Contains(handle)) {
SW.WriteLine("ERR - Handle already exists!");
handle = GetHandle();
}
TalkServ.handles.Add(handle,client);
TalkServ.handleByConnect.Add(client,handle);
TalkServ.SendSysMsg("** " + handle + " ** HAS JOINED US.");
SW.WriteLine("Now Talking.....\r\n-------------------------------");
SW.Flush();
Thread t = new Thread(new ThreadStart(run));
t.Start();
}
}

How To Send Email Via Web Services In Asp.Net

2014-03-20T19:59:00.003-07:00

How To Send Email Via Web Services In Asp.Net

To send Email via Web Services in ASP.Net Create a web method as given below:

public static void CreateMessageWithAttachment(string server)

{

// Specify the file to be attached and sent.

// This example assumes that a file named Data.xls exists in the

// current working directory.

string file = "myfile.xls";

// Create a message and set up the recipients.

MailMessage message = new MailMessage(

"naveenranjan@gmail.com",

"nr2info@gmail.com",

"Your data report.",

"See the attached File.");

// Create the file attachment for this e-mail message.

Attachment data = new Attachment(file, MediaTypeNames.Application.Octet);

// Add time stamp information for the file.

ContentDisposition disposition = data.ContentDisposition;

disposition.CreationDate = System.IO.File.GetCreationTime(file);

disposition.ModificationDate = System.IO.File.GetLastWriteTime(file);

disposition.ReadDate = System.IO.File.GetLastAccessTime(file);

// Add the file attachment to this e-mail message.

message.Attachments.Add(data);

//Send the message.

SmtpClient client = new SmtpClient(server);

// Add credentials if the SMTP server requires them.

client.Credentials = CredentialCache.DefaultNetworkCredentials;

try {

client.Send(message);

}

catch (Exception ex) {

Console.WriteLine("Exception caught in CreateMessageWithAttachment(): {0}",

ex.ToString() );

}

// Display the values in the ContentDisposition for the attachment.

ContentDisposition cd = data.ContentDisposition;

Console.WriteLine("Content disposition");

Console.WriteLine(cd.ToString());

Console.WriteLine("File {0}", cd.FileName);

Console.WriteLine("Size {0}", cd.Size);

Console.WriteLine("Creation {0}", cd.CreationDate);

Console.WriteLine("Modification {0}", cd.ModificationDate);

Console.WriteLine("Read {0}", cd.ReadDate);

Console.WriteLine("Inline {0}", cd.Inline);

Console.WriteLine("Parameters: {0}", cd.Parameters.Count);

foreach (DictionaryEntry d in cd.Parameters)

{

Console.WriteLine("{0} = {1}", d.Key, d.Value);

}

data.Dispose();

}

Print GridView Data Using JavaScript in ASP.Net

2014-03-20T19:50:00.002-07:00

How to Print gridview data in asp.net using C#

To print GridView Data using JavaScript follow this steps.

Take a GridView Control on your ASP.Net Page.
Bind the GridView as Per ADO.Net.
Then Write the JavaScript Code as below to print the gridView Data .

Print Gridview Data in asp.net

Print Gridview Data

Benefits of Using Assembly in .Net Framework 4.5

2014-03-19T19:55:00.003-07:00

Benefits of Using Assembly in .Net Framework 4.5

Assemblies are designed to simplify application deployment and to solve versioning problems that can occur with component-based applications.

End users and developers are familiar with versioning and deployment issues that arise from today's component-based systems. Some end users have experienced the frustration of installing a new application on their computer, only to find that an existing application has suddenly stopped working. Many developers have spent countless hours trying to keep all necessary registry entries consistent in order to activate a COM class.

Many deployment problems have been solved by the use of assemblies in the .NET Framework. Because they are self-describing components that have no dependencies on registry entries, assemblies enable zero-impact application installation. They also simplify uninstalling and replicating applications.

Problems in Versioning

Currently two versioning problems occur with Win32 applications:

Versioning rules cannot be expressed between pieces of an application and enforced by the operating system. The current approach relies on backward compatibility, which is often difficult to guarantee. Interface definitions must be static, once published, and a single piece of code must maintain backward compatibility with previous versions. Furthermore, code is typically designed so that only a single version of it can be present and executing on a computer at any given time.
There is no way to maintain consistency between sets of components that are built together and the set that is present at run time.

These two versioning problems combine to create DLL conflicts, where installing one application can inadvertently break an existing application because a certain software component or DLL was installed that was not fully backward compatible with a previous version. Once this situation occurs, there is no support in the system for diagnosing and fixing the problem.

The Dll Hell Problems

Windows 2000 began to fully address these problems. It provides two features that partially fix DLL conflicts:

Windows 2000 enables you to create client applications where the dependent .dll files are located in the same directory as the application's .exe file. Windows 2000 can be configured to check for a component in the directory where the .exe file is located before checking the fully qualified path or searching the normal path. This enables components to be independent of components installed and used by other applications.
Windows 2000 locks files that are shipped with the operating system in the System32 directory so they cannot be inadvertently replaced when applications are installed.

The common language runtime uses assemblies to continue this evolution toward a complete solution to DLL conflicts.

Assembly Is Solution

To solve versioning problems, as well as the remaining problems that lead to DLL conflicts, the runtime uses assemblies to do the following:

Enable developers to specify version rules between different software components.
Provide the infrastructure to enforce versioning rules.
Provide the infrastructure to allow multiple versions of a component to be run simultaneously (called side-by-side execution).

Assembly Versioning in .Net Framework 4.5

2014-03-19T19:45:00.002-07:00

Assembly Versioning in .Net Framework 4.5

All versioning of assemblies that use the common language runtime is done at the assembly level. The specific version of an assembly and the versions of dependent assemblies are recorded in the assembly's manifest. The default version policy for the runtime is that applications run only with the versions they were built and tested with, unless overridden by explicit version policy in configuration files (the application configuration file, the publisher policy file, and the computer's administrator configuration file).

Versioning is done only on assemblies with strong names.

The runtime performs several steps to resolve an assembly binding request:

Checks the original assembly reference to determine the version of the assembly to be bound.
Checks for all applicable configuration files to apply version policy.
Determines the correct assembly from the original assembly reference and any redirection specified in the configuration files, and determines the version that should be bound to the calling assembly.
Checks the global assembly cache, codebases specified in configuration files, and then checks the application's directory and subdirectories .

Version Information

Each assembly has two distinct ways of expressing version information:

The assembly's version number, which, together with the assembly name and culture information, is part of the assembly's identity. This number is used by the runtime to enforce version policy and plays a key part in the type resolution process at run time.
An informational version, which is a string that represents additional version information included for informational purposes only.

Assembly Version Information

Each assembly has a version number as part of its identity. As such, two assemblies that differ by version number are considered by the runtime to be completely different assemblies. This version number is physically represented as a four-part string with the following format:

<major version>.<minor version>.<build number>.<revision>

For example, version 1.5.1254.0 indicates 1 as the major version, 5 as the minor version, 1254 as the build number, and 0 as the revision number.

The version number is stored in the assembly manifest along with other identity information, including the assembly name and public key, as well as information on relationships and identities of other assemblies connected with the application.

When an assembly is built, the development tool records dependency information for each assembly that is referenced in the assembly manifest. The runtime uses these version numbers, in conjunction with configuration information set by an administrator, an application, or a publisher, to load the proper version of a referenced assembly.

The runtime distinguishes between regular and strong-named assemblies for the purposes of versioning. Version checking only occurs with strong-named assemblies.

Assembly Informational Version

The informational version is a string that attaches additional version information to an assembly for informational purposes only; this information is not used at run time. The text-based informational version corresponds to the product's marketing literature, packaging, or product name and is not used by the runtime. For example, an informational version could be "Common Language Runtime version 1.0" or "NET Control SP 2". On the Version tab of the file properties dialog in Microsoft Windows, this information appears in the item "Product Version".

How to SqlBulkCopy for high performance inserts in .Net

2014-03-19T09:52:00.000-07:00

How to use SqlBulkCopy for High Performance insert in ADO.Net

In the age of Object Relational Mapping frameworks (ORMs) it seems unusual to ever get “close to the metal” when it comes to persisting data. Developers are getting quite used to being abstracted away from the underlying data access technologies. However there are times when having a good understanding of what’s going on under the covers can allow you to look for alternative solutions when the ORM layer isn’t going to be as efficient as you need for a particular scenario. (This is actually true for all abstractions, not just ORMs.)

In a project I worked on about 5 years ago I implemented my own ORM. The application it was being developed for needed to save large sets of data to the database, anywhere between 100,000 and 1,000,000 records in a batch. For various reasons, all of this needed to operate within the ORM code-base; that is to say it wasn’t going to be possible to use a SQL Server DTS package to load the data. Running some performance tests showed that saving the data on a row by row basis by firing off multiple INSERT statements just wasn’t going to cut the mustard.

The most efficient way to accomplish this turned out to be the SqlBulkCopy class. Unfortunately there isn’t a simple way to get SqlBulkCopy to process through a collection of business entities. This article will show you how you can use SqlBulkCopy with any set of classes to insert new data into a database very quickly. (As an aside, this isn’t the code that I wrote all those years ago – this article takes advantage of .NET framework features that weren’t available back when the original framework was developed, which make things even better than before.)

Using SqlBulkCopy

There are 4 methods on the SqlBulkCopy API that write data to a database:

public void WriteToServer(IDataReader reader);

public void WriteToServer(DataTable table);

public void WriteToServer(DataTable table, DataRowState rowState);

public void WriteToServer(DataRow[] rows);

The last three of them are closely tied to DataTable-centric classes that were introduced with the first version of the .NET framework. Without copying the data from the objects into a completely different format, these particular methods aren’t going to be any use.

That leaves the first method that takes an IDataReader instance. Ideally it would be possible to create a generic ObjectDataReader and use that to feed WriteToServer with a set of objects. Sadly this doesn’t exist, so you’re going to have to implement your own.

public interface IDataReader : IDisposable, IDataRecord

{

int Depth { get; }

bool IsClosed { get; }

int RecordsAffected { get; }

void Close();

DataTable GetSchemaTable();

bool NextResult();

bool Read();

}

But as you can see, it also implements IDisposable (not a big deal) and IDataRecord (a slightly bigger deal). Putting the slightly menacing IDataRecord interface aside for now, this is what a generic implementation of IDataReader might look like:

public class ObjectDataReader : IDataReader

{

private IEnumerator dataEnumerator;

public ObjectDataReader(IEnumerable data)

{

this.dataEnumerator = data.GetEnumerator();

}

}

But as you can see, it also implements IDisposable (not a big deal) and IDataRecord (a slightly bigger deal). Putting the slightly menacing IDataRecord interface aside for now, this is what a generic implementation of IDataReader might look like:

public class ObjectDataReader : IDataReader
{
private IEnumerator dataEnumerator;
public ObjectDataReader(IEnumerable data)
{
this.dataEnumerator = data.GetEnumerator();
}
}

The constructor takes an enumerable of whatever generic type the data reader is constructed with. This is used to get an enumerator that will be used to iterate through the data.

public bool Read()
{
if (this.dataEnumerator == null)
{
throw new ObjectDisposedException("ObjectDataReader");
}
return this.dataEnumerator.MoveNext();

}

Other than making sure the instance hasn’t been disposed, Read just moves the enumerator onto the next item and returns the result of doing so. This will be true if there was another item to move to, or false if the enumerator has run
out of items.

public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this.dataEnumerator != null)
{
this.dataEnumerator.Dispose();
this.dataEnumerator = null;
}
}

}

The dispose methods follow the standard Dispose pattern – the only thing that needs cleaning up there is the enumerator that was created during the constructor call.

public void Close()
{
this.Dispose();
}
public bool IsClosed
{
get { return this.dataEnumerator == null; }

}

IsClosed just checks to see if the data reader has been disposed by checking if the enumerator is null, and Close is just a wrapper for Dispose. As an aside, I don’t really like there being two ways to dispose an object, but it’s in the interface so it’s best to implement it.

The rest of the IDataReader members (GetSchemaTable, NextResult, Depth and RecordsAffected) aren’t relevant to this implementation.

There’s nothing really complicated there; all the code does so far is iterate through the values yielded by an enumerator, which is nothing more than a foreach statement can do for us. That’s why we have to implement IDataRecord as well, and this is where the fun starts.

using IDataRecord

The IDataRecord interface provides access to the values held within the current record the IDataReader is pointing to. In a traditional sense IDataRecord would be responsible for returning values from the columns returned by a database query or the columns in a data table. This column-centric view of the world is a bit of a problem, as you’ll see very shortly.

The IDataRecord interface contains a lot of members, but most of them aren’t called during the SqlBulkCopy process. In fact, of the 24 properties and methods it defines, only 3 need to be implemented:

int FieldCount { get; }

int GetOrdinal(string name)

object GetValue(int i)

GetValue is the most important method as it is the one that SqlBulkCopy calls to get values from each of the properties. Notice that GetValue only takes an integer parameter: the ordinal position of the column to read. This is the problem I alluded to earlier as this doesn’t make much sense in an object-based context where properties need to be read.

FieldCount is just used to return the number of columns (or properties) on the current record and GetOrdinal is a method that supports GetValue by providing the ordinal index for a column/property name.

So somehow you need to map the properties of the class to an ordinal index value. The first step to accomplishing this is to use reflection to find all the readable properties on the type of class:

public ObjectDataReader(IEnumerable data)

{

this.dataEnumerator = data.GetEnumerator();

var propertyAccessors = typeof(TData)

.GetProperties(BindingFlags.Instance | BindingFlags.Public)

.Where(p => p.CanRead)

.Select((p, i) => new

{

Index = i,

Property = p,

Accessor = CreatePropertyAccessor(p)

})

.ToArray();

}

This ugly looking code creates an anonymous type for each property defined on TData, comprising the ordinal index of the property, the PropertyInfo for the property and an accessor for the property created by a method called CreatePropertyAccessor. CreatePropertyAccessor is a method that takes a PropertyInfo and creates a delegate capable of reading from the property for an instance of the class. You’ll see this method implemented shortly.

The rest of the constructor just creates two lookups:

The first is an array of the property accessors – these are stored in the order they were discovered in the class, i.e. ordinal order.
The second is a dictionary keyed on property names, the values being the ordinal index of the property in the array lookup.

this.accessors = propertyAccessors.Select(p => p.Accessor).ToArray();

this.ordinalLookup = propertyAccessors.ToDictionary(

p => p.Property.Name,

p => p.Index,

StringComparer.OrdinalIgnoreCase);

We now have enough information to implement the three methods of IDataRecord. FieldCount is simple – it’s just the number of property accessors that have been generated.

public int FieldCount

{

get { return this.accessors.Length; }

}

GetOrdinal is just a case of looking up in the dictionary to obtain the ordinal index of the property with the given name. Just to be safe there’s a check to ensure that there is a property with a matching name.

public int GetOrdinal(string name)

{

int ordinal;

if (!this.ordinalLookup.TryGetValue(name, out ordinal))

{

throw new InvalidOperationException("Unknown parameter name " + name);

}

return ordinal;

}

GetValue simply gets the accessor at the given ordinal index and executes it, passing in the current instance of the class. The accessor will return the value of the property.

public object GetValue(int i)

{

if (this.dataEnumerator == null)

{

throw new ObjectDisposedException("ObjectDataReader");

}

return this.accessors[i](this.dataEnumerator.Current);

}

Creating the accessors

In theory, having the PropertyInfo for the class’s properties would be enough for us to read property values as we could just use PropertyInfo.GetValue. However given that there is an overhead with using reflection and performance is a consideration, CreatePropertyAccessor generates an accessor that is compiled at runtime for each of the properties using expression trees. Here’s the implementation:

private Func CreatePropertyAccessor(PropertyInfo p)

{

// Define the parameter that will be passed - will be the current object

var parameter = Expression.Parameter(typeof(TData), "input");

// Define an expression to get the value from the property

var propertyAccess = Expression.Property(parameter, p.GetGetMethod());

// Make sure the result of the get method is cast as an object

var castAsObject = Expression.TypeAs(propertyAccess, typeof(object));

// Create a lambda expression for the property access and compile it

var lamda = Expression.Lambda>(castAsObject, parameter);

return lamda.Compile();

}

Using ObjectDataReader

Here’s a demo command line application illustrating how the ObjectDataReader class could be used in conjunction with SqlBulkCopy to insert a randomly generated set of people into the MostWanted database:

namespace SqlBulkCopyExample

{

using System;

using System.Collections.Generic;

using System.Data;

using System.Data.SqlClient;

using System.Linq;

class Program

{

static void Main(string[] args)

{

var people = CreateSamplePeople();

using (var connection = new SqlConnection(

"Server=.;Database=MostWanted;Integrated Security=SSPI"))

{

var bulkCopy = new SqlBulkCopy(connection);

bulkCopy.DestinationTableName = "Person";

bulkCopy.ColumnMappings.Add("Name", "Name");

bulkCopy.ColumnMappings.Add("DateOfBirth", "DateOfBirth");

connection.Open();

using (var dataReader = new ObjectDataReader(people))

{

bulkCopy.WriteToServer(dataReader);

}

}

}

private static IEnumerable CreateSamplePeople(int count)

{

return Enumerable.Range(0, count)

.Select(i => new Person

{

Name = "Person" + i,

DateOfBirth = new DateTime(

1950 + (i % 50),

((i * 3) % 12) + 1,

((i * 7) % 29) + 1)

}

};

}

}

}

What is Master Page In Asp.Net

2014-03-19T08:35:00.003-07:00

What is Master Page In Asp.Net

A Master page offers a template for one or more web forms. It defines placeholders for the content, which can be overridden by the content pages. The content pages contains only content. When users request the content page, ASP.NET merges the layout of the master page with the content of the content page and produce output.

Advantages of using Master Page in ASP.NET

Master pages enables consistent and standardized layout to the website.You can make layout changes of the site in the master page instead of making change in the pages.It is very easy to implement

How to create Multiple Master Page

In ASP.NET, you can have multiple master pages each for a different purpose.You can provide users several layout options using Multiple Master Page. You can define Master Page at multiple places in the web application.

We can specify page-level using the @Page directive.
We can specify using the Web.config

Dynamic Data Provider(DDP) and EntityDataSource Control for EF6

2014-03-16T03:32:00.000-07:00

Dynamic Data Provider(DDP) and EntityDataSource

Control for Entity Framework 6

Microsoft has announced an update to ASP.NET DynamicData and EntityDataSource control, so that they work with Entity Framework 6.

How to install this preview

You can download this preview for ASP.NET DynamicData.EFProvider (http://www.nuget.org/packages/Microsoft.AspNet.DynamicData.EFProvider/) and EntityDataSource (http://www.nuget.org/packages/Microsoft.AspNet.EntityDataSource/) as preview NuGet packages from the NuGet gallery. You can install these pre-release packages through NuGet using the NuGet Package Manager Console, like this:

Install-Package Microsoft.AspNet.DynamicData.EFProvider -Version 6.0.0-alpha1 –Pre
Install-Package Microsoft.AspNet.EntityDataSource -Version 6.0.0-alpha1 –Pre

Microsoft.AspNet.DynamicData.EFProvider

This package has a DynamicData EFProvider for Entity Framework 6. This provider can work with a Model (either Code First or EF Designer) which was created using Entity Framework 6. This package also installs the Page Templates, Entity Templates and Field Templates which are required for DynamicData. The templates have been updated to useMicrosoft.AspNet.EntityDataSource control which we are also previewing today as well.

Following are the steps for using this package in a ASP.NET DynamicData application:

Create a new ASP.NET Dynamic Data Entities Web Application
Add the Microsoft.AspNet.DynamicData.EFProvider NuGet package
This will do the following
1. Add a reference to the DynamicData EFProvider binary
2. Install the templates. If you are starting with a new project, then you can override the templates. If you have an existing application, then you should be careful when overriding the changes. The templates replace the EntityDataSource control which shipped in .NET with Microsoft.AspNet.EntityDataSource and also have a few bug fixes in the Many-Many field template so they work with Entity Framework 6.
Create your model using Entity Framework Code First or EF Designer.

Add the following code in RegisterRoutes in Global.asax.cs to register your EF Model:

DefaultModel.RegisterContext(
    new Microsoft.AspNet.DynamicData.ModelProviders.EFDataModelProvider(
        () => newNorthwindEntities1()),
    newContextConfiguration { ScaffoldAllTables = true });

Run the project
You would see all the tables listed on the Default page.

Microsoft.AspNet.EntityDataSource Control

This is an update to the EntityDataSource control which shipped in the .NET Framework. The EntityDataSource control has been updated to work with Entity Framework 6.

To use this control, please do the following

Create an ASP.NET application
Install the package Microsoft.AspNet.EntityDataSource
1. This package will
  1. install the runtime binary for Microsoft.AspNet.EntityDataSource
  2. Install the EntityFramework version 6 NuGet package
  3. Add the following tag prefix in web.config
```
 
   
          tagPrefix="ef" 
      assembly="Microsoft.AspNet.EntityDataSource" 
      namespace="Microsoft.AspNet.EntityDataSource" /> 
   
 
```
Create a new Web Form page
Use the control as follows and bind it to any Databound control such as GridView, FormView etc.
```
 
```

Known Issues

The templates in Microsoft.AspNet.DynamicData.EFProvider are for C# only.
The templates in Microsoft.AspNet.DynamicData.EFProvider are for Web Application projects only and will not work for WebSites projects.