sri

The Dynamic Language Runtime

2009-06-15T01:48:00.000-07:00

The Dynamic Language Runtime (DLR) from Microsoft is an ongoing effort to bring a set of services that run on top of the Common Language Runtime (CLR) and provides language services for several different dynamic languages

Silverlight DLR is implemented on top of the CLR to allow both compilation and execution of dynamic code in runtime.
Without DLR, only the already-compiled code can execute. The good thing about DLR is that it can compile and execute code in Dynamic VB.NET, IronPython, IronRuby and Managed JScript—C# is not supported by the DLR yet—at a blazingly fast performance, as the dynamic code is first JIT-compiled before being executed. With DLR, we can now write dynamic code that can fully interact with Silverlight elements at runtime.
Supports the dynamic compilation and execution of scripting languages such as JavaScript and IronPython to program Silverlight-based applications. Includes a pluggable model for adding support for other languages for use with Silverlight.

The Silverlight Dynamic Languages SDK provides a bridge between Silverlight and the Dynamic Language Runtime (DLR). The SDK allows developers to use dynamic languages, running on the DLR, to build Silverlight applications. With this interoperation, dynamic languages can leverage the feature-rich Silverlight Framework Class Library (FCL), and dynamic languages can call into other dynamic languages, e.g., IronPython calling Managed JScript.
The SDK also includes services to build new languages on top of the DLR, including a shared, dynamic type system and a language hosting model. It also facilitates hosting dynamic languages inside of different hosts. Silverlight can be viewed as "simply an application host used to host the DLR," using the same services that can be utilized by an application developer.
To get started writing Silverlight applications in IronRuby, IronPython or Managed JScript, download the Silverlight Dynamic Languages SDK, which includes:
IronPython, IronRuby, and Managed JScript language libraries
Chiron, a dynamic language development utility
source code for IronPython, IronRuby, the Dynamic Language Runtime (DLR), and Chiron sample applications for both Ruby and Python
batch file used to run sample on Windows
shell script to run applications on Mac
Microsoft® Public License (Ms-PL)

WCF

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

WCF Tutorial
Objectives:
• Review the role of interface-based programming
• Review the role of XML web services
• Define Service-Oriented Architectures (SOAs)
• Review the core distributed APIs of the Microsoft Windows OS
• Understand the motivation behind Windows Communication Foundation (WCF)
• Take a first look at building and testing WCF services
• Learn to create self-hosting WCF services
• Declaratively define hosting logic within *.config files
• Define hosting logic programmatically
• Understand the role of Metadata Exchange (MEX)
• Generate and make use of client proxies
• Learn to host WCF services in a Windows service
• Learn to host WCF services in IIS virtual directories
• Define and invoke ‘one-way’ method operations
• Learn to invoke WCF service methods asynchronously
Overview
Building a distributed system is a very common task for many programmers. However, doing so involves confronting numerous design challenges. In this chapter, you will review two key aspects of many distributed systems (interfaces and XML web services), followed by an overview of Service-Oriented Architectures (SOAs). Also, you will survey several core distributed APIs found within the Windows OS.With this historical background in place, the remainder of this chapter will introduce you to the Windows Communication Foundation (WCF) API. Here you will learn about the problems WCF attempts to solve, study the ABC’s (addresses, bindings, and contracts) of building a WCF application, and explore some common WCF development tools.The information presented here will function as the backbone for the remainder of the class.A Working Definition of Windows Communication Foundation (WCF)
• To begin your examination of WCF, you will start with a review of common distributed programming practices and previously distributed APIs.
• This is important, given that WCF leverages many of the distributed concepts / APIs you may have used in the past.
• WCF is a .NET 3.0 (and higher) API that allows you to build distributed systems.
• WCF is unique in that you can select from many types of bindings. This fact alone makes WCF a very flexible framework.
• A single WCF service could be exposed via an HTTP binding for outwardly facing callers or via a TCP binding for in-house callers.
• The underlying plumbing details can be relegated to *.config files, which make it very simple to change bindings and other details on the fly.
• WCF makes extensive use of interface-based programming techniques.
• When you define a WCF service, you typically begin by defining the interfaces that model the functionality callers can expect to find.
• These .NET interfaces could be used by the runtime to generate WSDL definitions based on your choice of bindings.
• In addition, WCF makes heavy use of .NET attributes to qualify how the runtime should handle client / service interactions.
• Similar to the .NET remoting layer / XML web services, WCF attributes are used to control data formatting, binding operations, and more.
• Recall that attributes are essentially code annotations.
• Attributes are useless unless another piece of software reflects over them. In this case, the ‘other piece of software’ could be the WCF runtime as well as WCF development tools.
• WCF is heavily influenced by XML web services and Service-Oriented Architectures (SOAs) in general.
• Like an XML web service, WCF services make use of contracts and explicit boundaries and support the use of various WS-* specifications.
• However, a WCF service does not have to use web-service-centric bindings.
• If you wish, you can opt for P2P bindings, named pipes, TCP bindings, and so on.
• The underlying binding is decoupled from the service itself.
• Therefore, changing bindings on the fly is very straightforward
.• In a nutshell, as of .NET 3.0 (and higher), WCF is the preferred way to build new distributed systems.
• The original distributed .NET APIs (System.Runtime.Remoting, System.Web.Services, and so forth) are still supported.
• Furthermore, Visual Studio still has templates for ‘traditional’ ASP.NET web service project workspaces.
• It is also possible to migrate existing XML web services / remoting applications into the WCF programming model.
• Doing so, however, may offer little benefit. In fact, it could entail a good amount of work.• This course does not cover migrating existing distributed systems into the WCF programming model.
• The class assumes you intend to build new WCF services, hosts, and clients.
• However, Appendix A illustrates how to interact with legacy COM+ components.
• You can read Appendix A if time / interest permits.
• The .NET Framework SDK documentation provides details of migrating existing systems.• If you are interested in migrating from .NET remoting to WCF, look up the article ‘From .NET Remoting to the Windows Communication Foundation (WCF)’.
• If you are interested in migrating from ASP.NET web services to WCF, look up the article ‘Migrating ASP.NET Web Services to WCF’.
• Finally, be aware that this class will focus on the core aspects of the programming model, which will be commonplace to all of your WCF projects.
• Consult the .NET Framework SDK documentation for WCF topics not addressed in this course.
• The WCF section of the SDK documentation provides a number of excellent code examples, white papers, and tutorials.• Simply look up the Windows Communication Foundation selection of the help system and dive in.

CHIRON

2009-06-14T23:38:00.000-07:00

What is Chiron?
The Chiron system provides tools for assisting in the development of graphical user interfaces and provides a run-time system for managing and supporting their dynamic behavior.
The objective of the Chiron system is to reduce long-term costs associated with developing and maintaining graphical user interface (GUI) software. It achieves this objective by providing key interface layers which are resilient to change. In particular, Chiron strongly separates an application from its user interface code, as well as separating the user interface code from the underlying toolkit substrates. Chiron supports the construction of GUIs which provide multiple coordinated views of application objects and allows flexible restructuring of the configuration of those views. Chiron supports a concurrent model of control. While the Chiron architecture supports heterogeneous, multi-lingual systems, the development tools which are part of this release only support clients (applications) written in Ada.
Chiron is a serverized system. The Chiron server and clients run in separate Unix processes. Within a client, artists are active interface agents that are bound to one or more objects. They encapsulate decisions about how objects should be depicted (presentations) as well as how they behave dynamically (dialogs). Multiple artists can be bound to a single object, providing coordinated multiple views of that object. A Chiron client is made up of application code, a set of artists, and client support code. The client support code implements initialization, event detection and routing, and communication with the server. Client support code is automatically generated by client building tools.
Chiron leverages from commercial GUI layout tools. Specifically, Chiron can be used with Sun Microsystem's DevGuide tool to create artists. For those aspects of GUIs which DevGuide is incapable of supporting (e.g. drawing on a canvas), DevGuide and Chiron tools can be used to create an artist template into which the additional graphical aspects can be added programmatically.
The Chiron server manages all aspects of the user interface that are not artist or application specific. It can be thought of as a virtual machine providing a high-level graphical "toolkit" interface to artists by means of an Abstract Depiction Language (ADL). The server receives ADL instructions from the artists and uses them to create and manipulate an internal abstract representation of the graphical interface. The representation is rendered to a concrete depiction (a user viewable image) via calls to the underlying window system. The server also listens for events from the window system (button push, menu selection, etc) and translates them to Chiron events before shipping them back to the appropriate client. The Chiron server provides flexibility in terms of windowing systems and toolkits, application languages, and process inter-connection topology. Although we currently only provide support for Ada clients, it is feasible to provide other language-specific interfaces to the server's ADL.
The Chiron model is highly concurrent. Most components maintain their own, and possibly multiple, threads of control. Thus, unlike most user interface architectures, Chiron avoids imposing sequential control upon tools, allowing the tool, the user interface, and the server, to run in parallel

USER CONTROL VS CUSTOM CONTROL

2009-06-14T23:26:00.000-07:00

1) Custom controls are written in separate program files that are compiled explicitly and are persisted as an assembly (.dll).User controls are authored using the ASP.NET page syntax, either in the script block or in CodeBehind pages and are implicitly just-in-time compiled by the ASP.NET runtime system.
2) Custom Controls are nicely suited for general re-use as they are easy to package and redistribute as third-party controls. User Controls are best suited for reuse within a web application. Because they are persisted as source files, less chances exist that third parties would like to distribute them.
3) Once created, a custom control can be added to the toolbox of a visual designer, such as Visual Studio .NET, and dragged and dropped onto a page— just like any built-in server control. The visual designer can also support visual manipulation of custom control’s various properties.User controls provide minimal support for use with a visual designer toolbox.
4) A custom control provides minimal support for design-time authoring in a visual designer.A user control provides design-time support for authoring in a visual designer—just like an ASP.NET page.
5) A custom controls inherits System.Web.UI.Control or System.Web.UI.WebControls.WebControl class with class hierarchy (bottom up) either MyCustomControl.Control.Object OR MyCustomControl. WebControl.Control. Object.A user control inherits System.Web.UI.UserControl class with class hierarchy (bottom up) MyUserControl. UserControl. TemplateControl. Control. Object.
6) A custom control is in the form of dynamic linked library (.dll), thus pre-compiled.A user control has extension .ascx and is JIT compiled
7) A custom control does not have any design editor. It may or may not inherit functionality of other standard control(s). It can be an entirely new one.A user control must encapsulate functionality of other web server control(s) through dragging and dropping in design mode.
8 ) A custom control does not have design editor so is harder to create.A user control is easy to create because it can be designed like a page is designed i.e. they have design editor and code behind simultaneously
9) A custom control (newly created or extended) is a separate and pre-compiled component.A user control requires registration and instantiation per page and resides on a page as an object and is compiled along with the page. It is not in pre-compiled form
10) A custom control is more reusable because you do not need a separate copy of it for each application; it can automatically be loaded be from the GAC. Thus giving an advantage of being a framework wide component.A user control cannot be registered with Global Assembly Cache (GAC) .
11) A custom control’s class is not bound with any design. Here you can take the leverage of the flexibility and richness of .NET programming model; you can expose properties, override functions of the base class and also register complex client side logic in the class. A user control cannot provide the level of richness that a custom control can provide.
12) A custom control is the best choice especially when you want to make your controls redistributable, more reusable and make it a Visual Studio IDE aware component.A user control may fulfill your need if you are working on a single web application
13) A custom control cannot use the user control. A user control can use a custom control.
14) The custom control model is designed for authoring redistributable components in the form of an assembly (compiled class library) that can be used by a number of applications. The assembly containing the controls can be used by a single application at a time when placed in the application’s private bin directory, or it can be shared across multiple applications when placed into the global assembly cache, commonly referred to as the GAC. The assembly can be deployed and used in its compiled binary form without the associated source code.The user control model is designed for single-application scenarios. A user control is dynamically compiled at run time when a page that uses it is first requested. As a result, a user control must be deployed in source form, and the .ascx file (and its associated code-behind, if any exists) must be copied into every application that requires the user control.
15) Custom controls are authored by writing a managed class that derives directly or indirectly from System.Web.UI.Control in a .NET programming language.User controls are authored declaratively in the form of .ascx files, which is very similar to the way ASP.NET pages are designed and developed.

CUSTOM CONTROL

2009-06-14T23:24:00.000-07:00

· Exist in precompiled assemblies.
· Code entirely contained in .cs (or .vb)
· No visual designer. Any HTML code needs to be declared programmatically.
· Can be used in .aspx pages, user controls or other custom server controls.
· Can be added to the ToolBox (drag and drop)
· Can be shared between web applications.

Reusability of control (or extend functionalities of existing control)
We can add toolbox
Just drag and drop from toolbox
U can register user control to. Aspx page by Register tag
A single copy of the control is required in each application
Good for dynamics layout
Hard to create
Compiled in to dll
You can create a Custom control when it is going to be used across different applications.
Custom controls don't a visual interface.
Custom controls however can be added to your tool box and used in different applications without re-compiling.
It's a .dll

USER CONTROL

2009-06-14T23:21:00.000-07:00

· Have an ascx extension.
· Are compiled at runtime when the page is loaded.
· Visual design is possible, just like an aspx page and uses the ASP.Net page model with code behind file.
· Can only be used on a host aspx page or another user control.
· Cannot be added to the ToolBox.
· Can only be used in the current web application (source must be copied to another application to use).

We can’t add to toolbox
Just drag and drop from solution explorer to page (aspx)
U can register user control to. Aspx page by Register tag
A separate copy of the control is required in each application
Good for static
Easier to create8)
Not complied into DLL
Here page (user page) can be converted as control then We can use as control in aspx
Reusability web page

Animation in silverlight

2009-06-10T03:18:00.000-07:00

Animation in silverlight
The Importance of an Impressive User Interface
Microsoft and other companies have invested millions of dollars in software research and development. The primary factors that affect and influence end users are performance and the user interface. The compilation of factors that influence the end user are referred to as the "user experience" (UX). Software developers are on a continual quest to improve application performance, however new rules and guidelines have recently been introduced that define higher standards for the creation of user interfaces. The new guidelines were primarily released by Microsoft and coincide with the release of Windows Vista, WPF, and, in turn, Silverlight.
Basically, the more impressed a user is with the overall user experience that an application provides, the more impressed they will be with the application and the more likely they will be to refer the application to others. This module, obviously, focuses on how to create user interfaces by using Silverlight.
Drawing Graphics
Silverlight is a subset of WPF as applied by using principles of an extended ASP.NET AJAX. As such, Silverlight implements many of the features included in WPF. For instance, Silverlight provides the ability to draw two-dimensional (2D) graphics in applications. Graphics of this caliber are more than adequate for most user interfaces and applications, particularly business applications. However, there are applications which require more elaborate graphic capabilities, three-dimensional graphics (3D). For example, an engineering application may benefit tremendously from 3D graphics in the user interface. Whilst WPF provides 3D graphics, Silverlight, currently, does not.
In order to provide 3D graphics, an application must utilize the hardware of the local workstation and the facilities of the local operating system. Silverlight is designed to be cross-platform and cross-browser compliant. With that in mind, it cannot be tied to any particular hardware configuration, operating system, or browser. This design coincides very well with the design goals of Silverlight but does not lend itself to rendering 3D graphics.
Silverlight, currently, does not support 3D graphics but may do so in a future version.
Graphic Elements
Drawing in Silverlight is accomplished through the use of graphic elements such as an ellipse or a rectangle. All graphic elements in Silverlight extend the Shape type. As a result, all Shape type objects in Silverlight include some common functionality as listed below:
Stroke: the stroke defines the outline of the shape
StrokeThickness: the stroke thickness defines the thickness of the outline of the shape
Fill: the fill defines how the interior of the shape is filled or painted
Lines
To draw lines in Silverlight, use the Line object. A line can easily be drawn on a canvas by using Blend and can be created directly in XAML by using Visual Studio 2008. A line is defined through the definition of two points. Each point is comprised of a combination of an X coordinate and a Y coordinate.
The markup snippet shown below is used to render a red, diagonal line from 10, 10 to 100, 100.
The canvas that results from the markup snippet above is shown in the following figure.
Ellipses
An Ellipse object is used to draw round objects in Silverlight. The circular characteristics of an ellipse are defined by specifying the height and width of the ellipse. The markup snippet shown below renders an oval ellipse with a blue gradient fill and a stroke of 3.
Sometimes, when using a graphical design tool, such as Blend, it may be tough to create an exact circle. To create a circle with a Silverlight ellipse, ensure that the height and width values are the same. To create a circle in Blend, when sizing the ellipse, hold down the Shift key. The markup snippet below renders a circle with a diameter of 100px, a stroke of 3, a green fill, and a yellow stroke.
The result of the two ellipse definitions above is shown in the figure below.
Rectangles
The Rectangle class is used to draw rectangles in Silverlight. The markup snippet below illustrates drawing two rectangles, a larger, blue rectangle in the background and a smaller, orange rectangle on top.
Just as with an ellipse, when sizing a rectangle by using Blend, if you want to draw a square or maintain the current aspect ratio of the rectangle, hold down the shift key. The result of the markup above is shown in the figure below.
Paths and Geometries
The Path object also derives from the Shape object, however, the Path object has no defined shape. Instead, a Path accepts an indirect or abstract definition of a shape to define how the Path is rendered. The Geometry class is used to define how a Shape is rendered. There is only one Path class but many types of Geometry classes. The Geometry class itself is an abstract class that cannot be directly instantiated but one of its child classes must be instantiated.
The Path class can be used to define simple shapes such as lines, ellipses, and rectangles in the same manner as the Line, Ellipse, and Rectangle classes, however the PathGeometry class is used to create more complex shapes. Creating paths can be rather tricky by hand coding the path coordinates directly in XAML. When using a design tool, such as Blend, paths are created as a combination of simpler elements or freehand by using a pen / pencil tool. The markup snippet below shows several path elements that were rendered in Blend when a sketchy little stick man was quickly drawn with the pencil tool.
The result of the markup shown above is shown in the following figure.
There are several types of geometries that can be utilized with a path including a LineGeometry, a RectangleGeometry, an EllipseGeometry, and a PathGeometry. The PathGeometry can compile complex shapes from multiple path segments. Path segments include arcs, bÃ©ziers, lines, and variations of each.
The PathGeometry is used above in shorthand form. The Path object includes a Data attribute that accepts multiple coordinates to define points along the path. Upon closer look, you will notice that the Data attribute value also contains characters such as "M" or "C". The Data attribute value is actually a mini markup language and the characters are very meaningful as well as case-sensitive. For instance, an uppercase "M" signifies a move command and the coordinates that follow indicate the movement of the path.
Brushes
Brushes are used to paint spaces contained by a stroke, or border or the stroke itself. For instance, a brush can be used to paint the interior space of a rectangle. In fact, in the rectangles example above, a gradient brush is used to paint the interior of the rectangle as shown in the markup snippet below.
Brushes can be used to paint solid colors, gradients, images, and even video. The ability to paint with images is fairly common among graphic design tools, however the ability to paint with video is only available in a very few elite graphic tools. Expression Blend currently supports image and video brushes but only for WPF and not for Silverlight applications.
However, it's fairly easy to create an image brush fill as shown in the markup snippet below.
The result of the markup snippet above is shown in the following figure.
To paint by using video, a little more work is required. First, a VideoBrush does not directly play video but utilizes video from another source such as a MediaElement object. The MediaElement object is discussed again in the section below. In the example below, video is being played as the fore ground of text. The TextBlock.ForeGround utilizes a VideoBrush that, in turn, utilizes video from a MediaElement object.
The result of the markup above is shown in the figure below with video playing as text.
Transformations
Transformation objects are used to transform other Shape objects. There are various types of transformations including rotations, scales, skews, and translations. A scale is a resize. A skew transformation skews the shape of the Shape. A translate moves a shape.
The markup snippet below illustrates applying a 45 degree rotation to a TextBlock.

FAQ

2009-06-10T03:16:00.000-07:00

http://www.dotnetfunda.com/articles/article293.aspx#What is XAML
http://www.dotnetfunda.com/misc/articles/default.aspx?start=300&page=6&cat=48&catname=Articles
http://www.dotnetfunda.com/articles/ShowCatArticle.aspx?category=83

link

2009-06-10T03:15:00.000-07:00

Dependency properties provide support for value expressions, data binding, animation, and property change notification.
http://www.componentone.com/newimages/products/datasheets/studioforsilverlight.pdf
tutoral
http://www.dotnetfunda.com/tutorials/silverlight/animation.aspx

Delegate

2009-06-10T03:11:00.000-07:00

Delegate
A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked
The signature of a single cast delegate is shown below:
delegate result-type identifier ([parameters]);
where:
result-type: The result type, which matches the return type of the function.
identifier: The delegate name.
parameters: The Parameters, that the function takes.
Delegates have the following properties:
• Delegates are similar to C++ function pointers, but are type safe.
• Delegates allow methods to be passed as parameters.
• Delegates can be used to define callback methods.
• Delegates can be chained together; for example, multiple methods can be called on a single event.
• Methods don't need to match the delegate signature exactly. For more information, see Covariance and Contravariance
• C# version 2.0 introduces the concept of Anonymous Methods, which permit code blocks to be passed as parameters in place of a separately defined method.

dll creation

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

STEPS

1.Start-Program-microsoft Visual studio 2008

2.File-New-New Project

2.1new->silverlightclasslibray

22.New folder->themes->Generic.xaml

2.3.

2.4.new folder->Button->Class.cs

dll

2009-06-08T23:35:00.000-07:00

What is a DLL?
A DLL is a library that contains code and data that can be used by more than one program at the same time. For example, in Windows operating systems, the Comdlg32 DLL performs common dialog box related functions. Therefore, each program can use the functionality that is contained in this DLL to implement an Open dialog box. This helps promote code reuse and efficient memory usage.By using a DLL, a program can be modularized into separate components. For example, an accounting program may be sold by module. Each module can be loaded into the main program at run time if that module is installed. Because the modules are separate, the load time of the program is faster, and a module is only loaded when that functionality is requested.Additionally, updates are easier to apply to each module without affecting other parts of the program. For example, you may have a payroll program, and the tax rates change each year. When these changes are isolated to a DLL, you can apply an update without needing to build or install the whole program again.
The following list describes some of the files that are implemented as DLLs in Windows operating systems:
ActiveX Controls (.ocx) filesAn example of an ActiveX control is a calendar control that lets you select a date from a calendar.
Control Panel (.cpl) filesAn example of a .cpl file is an item that is located in Control Panel. Each item is a specialized DLL.
Device driver (.drv) filesAn example of a device driver is a printer driver that controls the printing to a printer.
DLL advantages
The following list describes some of the advantages that are provided when a program uses a DLL:
Uses fewer resources
When multiple programs use the same library of functions, a DLL can reduce the duplication of code that is loaded on the disk and in physical memory. This can greatly influence the performance of not just the program that is running in the foreground, but also other programs that are running on the Windows operating system.
Promotes modular architectureA
DLL helps promote developing modular programs. This helps you develop large programs that require multiple language versions or a program that requires modular architecture. An example of a modular program is an accounting program that has many modules that can be dynamically loaded at run time.
Eases deployment and installation
When a function within a DLL needs an update or a fix, the deployment and installation of the DLL does not require the program to be relinked with the DLL. Additionally, if multiple programs use the same DLL, the multiple programs will all benefit from the update or the fix. This issue may more frequently occur when you use a third-party DLL that is regularly updated or fixed.
DLL dependencies
When a program or a DLL uses a DLL function in another DLL, a dependency is created. Therefore, the program is no longer self-contained, and the program may experience problems if the dependency is broken.
For example, the program may not run if one of the following actions occurs:
A dependent DLL is upgraded to a new version.
A dependent DLL is fixed.
A dependent DLL is overwritten with an earlier version.
A dependent DLL is removed from the computer.
These actions are generally known as DLL conflicts. If backward compatibility is not enforced, the program may not successfully run.
The following list describes the changes that have been introduced in Microsoft Windows 2000 and in later Windows operating systems to help minimize dependency issues:
Windows File Protection
In Windows File Protection, the operating system prevents system DLLs from being updated or deleted by an unauthorized agent. Therefore, when a program installation tries to remove or update a DLL that is defined as a system DLL, Windows File Protection will look for a valid digital signature.
Private DLLs

Private DLLs let you isolate a program from changes that are made to shared DLLs. Private DLLs use version-specific information or an empty .local file to enforce the version of the DLL that is used by the program. To use private DLLs, locate your DLLs in the program root folder. Then, for new programs, add version-specific information to the DLL. For old programs, use an empty .local file. Each method tells the operating system to use the private DLLs that are located in the program root folder.
DLL troubleshooting tools
Several tools are available to help you troubleshoot DLL problems. The following tools are some of these tools.
Dependency Walker
The Dependency Walker tool can recursively scan for all dependent DLLs that are used by a program. When you open a program in Dependency Walker, Dependency Walker performs the following checks:

Dependency Walker checks for missing DLLs.
Dependency Walker checks for program files or DLLs that are not valid.
Dependency Walker checks that import functions and export functions match.
Dependency Walker checks for circular dependency errors.
Dependency Walker checks for modules that are not valid because the modules are for a different operating system.

By using Dependency Walker, you can document all the DLLs that a program uses. This may help prevent and correct DLL problems that may occur in the future. Dependency Walker is located in the following directory when you install Microsoft Visual Studio 6.0:
drive\Program Files\Microsoft Visual Studio\Common\Tools
DLL Universal Problem Solver
The DLL Universal Problem Solver (DUPS) tool is used to audit, compare, document, and display DLL information.

The following list describes the utilities that make up the DUPS tool:
Dlister.exe: This utility enumerates all the DLLs on the computer and logs the information to a text file or to a database file.
Dcomp.exe :This utility compares the DLLs that are listed in two text files and produces a third text file that contains the differences.
Dtxt2DB.exe : This utility loads the text files that are created by using the Dlister.exe utility and the Dcomp.exe utility into the dllHell database.
DlgDtxt2DB.exe :This utility provides a graphical user interface (GUI) version of the Dtxt2DB.exe utility.
For more information about the DUPS tool, click the following article number to view the article in the Microsoft Knowledge Base:
247957 (http://support.microsoft.com/kb/247957/ ) Using DUPS.exe to resolve DLL compatibility problems
DLL development
This section describes the issues and the requirements that you should consider when you develop your own DLLs.
Types of DLLs
When you load a DLL in an application, two methods of linking let you call the exported DLL functions. The two methods of linking are load-time dynamic linking and run-time dynamic linking.
Load-time dynamic linking
In load-time dynamic linking, an application makes explicit calls to exported DLL functions like local functions. To use load-time dynamic linking, provide a header (.h) file and an import library (.lib) file when you compile and link the application. When you do this, the linker will provide the system with the information that is required to load the DLL and resolve the exported DLL function locations at load time.
Run-time dynamic linking
In run-time dynamic linking, an application calls either the LoadLibrary function or the LoadLibraryEx function to load the DLL at run time. After the DLL is successfully loaded, you use the GetProcAddress function to obtain the address of the exported DLL function that you want to call. When you use run-time dynamic linking, you do not need an import library file.

The following list describes the application criteria for when to use load-time dynamic linking and when to use run-time dynamic linking:
Startup performanceIf the initial startup performance of the application is important, you should use run-time dynamic linking.
Ease of useIn load-time dynamic linking, the exported DLL functions are like local functions. This makes it easy for you to call these functions.
Application logicIn run-time dynamic linking, an application can branch to load different modules as required. This is important when you develop multiple-language versions.
The .NET Framework assembly
With the introduction of Microsoft .NET and the .NET Framework, most of the problems that are associated with DLLs have been eliminated by using assemblies. An assembly is a logical unit of functionality that runs under the control of the .NET common language runtime (CLR). An assembly physically exists as a .dll file or as an .exe file. However, internally an assembly is very different from a Microsoft Win32 DLL.An assembly file contains an assembly manifest, type metadata, Microsoft intermediate language (MSIL) code, and other resources. The assembly manifest contains the assembly metadata that provides all the information that is required for an assembly to be self-describing.

The following information is included in the assembly manifest:
Assembly name
Version information
Culture information
Strong name information
The assembly list of files
Type reference information
Referenced and dependent assembly information
The MSIL code that is contained in the assembly cannot be directly executed. Instead, MSIL code execution is managed through the CLR. By default, when you create an assembly, the assembly is private to the application. To create a shared assembly requires that you assign a strong name to the assembly and then publish the assembly in the global assembly cache.

The following list describes some of the features of assemblies compared to the features of Win32 DLLs:
Self-describingWhen you create an assembly, all the information that is required for the CLR to run the assembly is contained in the assembly manifest. The assembly manifest contains a list of the dependent assemblies. Therefore, the CLR can maintain a consistent set of assemblies that are used in the application. In Win32 DLLs, you cannot maintain consistency between a set of DLLs that are used in an application when you use shared DLLs.
VersioningIn an assembly manifest, version information is recorded and enforced by the CLR. Additionally, version policies let you enforce version-specific usage. In Win32 DLLs, versioning cannot be enforced by the operating system. Instead, you must make sure that DLLs are backward compatible.
Side-by-side deploymentAssemblies support side-by-side deployment. One application can use one version of an assembly, and another application can use a different version of an assembly. Starting in Windows 2000, side-by-side deployment is supported by locating DLLs in the application folder. Additionally, Windows File Protection prevents system DLLs from being overwritten or replaced by an unauthorized agent.
Self-containment and isolationAn application that is developed by using an assembly can be self-contained and isolated from other applications that are running on the computer. This feature helps you create zero-impact installations.
ExecutionAn assembly is run under the security permissions that are supplied in the assembly manifest and that are controlled by the CLR.
Language independentAn assembly can be developed by using any one of the supported .NET languages. For example, you can develop an assembly in Microsoft Visual C#, and then use the assembly in a Microsoft Visual Basic .NET project.

msdn

2009-06-08T23:29:00.000-07:00

http://msdn.microsoft.com/en-us/library/8wbhsy70.aspx

WEB SERVICES

2009-06-08T22:52:00.000-07:00

What are web services?

Web services are application components
Web services communicate using open protocols
Web services are self-contained and self-describing
Web services can be discovered using UDDI
Web services can be used by other applications
XML is the basis for Web services

Web services platform elements:

SOAP (Simple Object Access Protocol)
UDDI (Universal Description, Discovery and Integration)
WSDL (Web Services Description Language)
Web services can offer applications components like currency conversion, weather reports, or even language translation as services.
Ideally, there will be only one type of each application component, and anyone can use it in their application.

SOAP (Simple Object Access Protocol)
SOAP is a simple XML-based protocol to let applications exchange information over HTTP.
Or more simple: SOAP is a protocol for accessing a Web Service.
SOAP stands for Simple Object Access Protocol
SOAP is a communication protocol
SOAP is a format for sending messages
SOAP is designed to communicate via Internet
SOAP is platform independent
SOAP is language independent
SOAP is based on XML
SOAP is simple and extensible
SOAP allows you to get around firewalls
SOAP is a W3C standard

What is WSDL?

WSDL is an XML-based language for describing Web services and how to access them.
WSDL stands for Web Services Description Language
WSDL is based on XML
WSDL is used to describe Web services
WSDL is also used to locate Web services
WSDL is a W3C standard

What is UDDI?

UDDI is a directory service where businesses can register and search for Web services.
UDDI stands for Universal Description, Discovery and Integration
UDDI is a directory for storing information about web services
UDDI is a directory of web service interfaces described by WSDL
UDDI communicates via SOAP
UDDI is built into the Microsoft .NET platform

FEATURES OF WPF

2009-06-08T21:23:00.000-07:00

FEATURES OF WPF

Document
Ø is a class that can read documents
ØXAML documents can be updated on the fly and built at runtime.
ØExcellent example is using XSLT to create nice documents from simple markup tags.
ØDemo of Rich Reading Experience

Graphical Services
•All graphics, including desktop items like windows, are Direct3D applications.
ØSupports vector-based graphics, which allow lossless scaling.
ØSupports 3D model rendering and interaction in 2D applications.
•Interactive 2D content can be overlaid on 3D

surfaces, natively

3D Graphics
•Graphics in 3D are totally different with different controls/objects
•Viewport3D – a window into a 3D world
•Camera
•Objects
•Materials Brush
•Mesh

Media Services

ØWPF provides tighter integration with other features like user interface (UI), documents, and media. This makes it possible to have 3D UI, 3D documents, and 3D media.
ØThere is support for most common image formats.
ØWPF supports the video formats WMV, MPEG and some AVI files by default, but since it is Windows Media Player running beneath, WPF can use all the codecs installed for it.

ClearType & Antialiasing
•WPF supports ClearType fonts, which results in better readibility and comprehension.
•WPF also supports alti-aliasing, which rounds off rough pixel edges.

Data Binding
WPF has a built-in set of data services to enable application developers to bind and manipulate data within applications.
There exists support for three types of data binding:
Øone time: where the client ignores updates on the server.
Øone way: where the client has read-only access to data.
Øtwo way: where client can read from and write data to the server.

Multimedia
•Key feature of WPF and Silverlight allows integration of video, audio and speech
•TAG are
•Soundplayer (limited to WAV files only)
ØMediaPlayer (MP3 with full control)
ØMediaElement Video

Resources

2009-06-07T22:13:00.000-07:00

Resources
Silverlight application is actually a package of files that's archived using ZIP compression and stored as a single file, with the extension .xap.
In a simple application, the XAP file has little more than a manifest (which list the files your project uses) and your application assembly. However, there's something else you can place in the XAP file—resources.
A XAP resource is a distinct file that you want to make available to your compiled application.
Examples include graphical assets—images, sounds, and video files that you want to display in your user interface.
· In the application assembly. The resource file is embedded in the compiled DLL file for your project, such as SilverlightApplication1.dll.
· In the application package. The resource file is placed in the XAP file alongside your application assembly. It's still just as easy to deploy, but now it's a bit easier to manage, because you replace or modify your assets by editing the XAP file, without compiling your application.
· On the site of origin. The resource file is placed on the website alongside your XAP file.
Example, you can use images in ordinary HTML web pages, or make videos available for easy downloading. You can reduce the size of the initial XAP download, which is important if the resources are large.

RIA

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

Rich Internet Applications
Ø Rich Internet Application is a web application resembling the features of a desktop application
Ø A cross between browser-based Web applications and traditional desktop applications
Ø It provides an end user experience similar to client/server applications supported by rich graphical user interface.
BENEFITS OF RIA
Enhanced user experience:
· This ensures that customers are drawn to your specific web site because it is simple and functional.
· Users complete more transactions and forms because they understand the interface since it is very similar to standard windowing desktops and applications.
· Employees get more work done with less errors
Reduced server load:
· Due to the application being run in the users browser, there is a significant reduction in the
number of web page reloads – enhancing the user experience.
Lost data:
· No more lost user data due to users closing browser sessions or accidentally using the “back button”.
Real business benefits :
Ø Offer users a richer, more engaging experience
Ø Keep pace with users' rising expectations
Ø Increase customer loyalty and generate higher profits.
Ø Leverage existing personnel ,processes ,and infrastructure.
Ø Highly responsive performance and reduced network load.
Ø Higher, richer and easier levels of interactive functionality
Ø Cost-effective way to deliver modern application with real business benefits
Other benefits
Ø Provide real time data and inventory management.
Ø Allow users to remotely monitor and manage data via a Web-based system.
Ø Reduce data complexity -- allow users to interactively visualize and manipulate complex data more effectively and easily.
Ø Provide immediate and dynamic visual feedback to the user.
Ø Allow for quicker task completion.
Ø Provide cross platform support.
BENEFITS OF RIA IN SILVERLIGHT :
The emergence of new technologies such Silverlight not only take performance management to the next level, but also enables the user to benefit from 'rich' UI and enhanced performance at the same time.
These technologies facilitate the users in various ways are
Ø A technology widely known as 'no-refresh', where the transition from one set of information to another is instantaneous and visually more appealing
Ø No major installation required. Updating and distributing the application is an instant and automatic process
Ø Users can use the application from any computer equipped with an Internet connection regardless of the operating system running on that computer
Ø Web-based applications are generally less prone to viral infections contrary to the desktop applications.
Ø Any .Net programming language is used (c#, Ruby,Python,VB)
Ø .Net based browser plug-in for rich features (animation,vector graphics and audio-video).
Ø Silverlight is a great boost to the performance, providing a high-performance execution environment inside of the browser.
Ø Silverlight enables applications that run within multiple browsers and operating systems (Windows and Macintosh) and built on web standards for pogrammability such as JavaScript, CSS and XML and the .NET CLR.
Ø The CLR is the core piece of .NET Framework.
Ø The CLR is a well-proven high-performance platform providing features like Garbage Collection, Just-In-Time compilation, Exception Management and a wide array of fully featured languages such as VB.NET and C# that are used
Features
Windowing environment:
· Multiple processes occurring within an application (i.e. timers, data transmission and retrieval, video loading).
· Cross-browser compatibility
· Rapid development & deployment
· Re-use of existing style sheets (retention of original web site appearance and branding)
· Intuitive data presentation to users via charts, diagrams, video, audio and other formats
· Leverages existing web-based infrastructure to keep implementation costs low
· Re-use existing back-end databases – the only change is the way the data is presented to the user
FEATURES OF RIA :
Ø Run in a web browser, not requiring installation.
Ø Run locally in a secure environment called a sandbox.
Ø Users can use the application from any computer with an internet connection .
Ø Cross-platform availability
Ø Fast interface response time with no page refresh
Ø Common UI behaviors like drag & drop and the ability to work online and offline
Ø Common calculation that happens on the client (e.g., an insurance rate calculator)
Ø Instant update of the application
Applications
· Financial Services
· Auto Dealerships
· Mortgage Firms
· Customer survey forms
· Email forms
· Video Distribution (branding/licensing)
· Remote training services
· Customer service (live two-way video, chat & assistance)
· _Virtual Desktop Environments
· CRM/ERP front-end applications
RIA TOOLS
· Silverlight
· Flex
· AJAX (DOM with framework like GWT)
· Java FX
· OpenLazlo
· Macromedia Flash Player

Silverlight

2009-06-07T22:02:00.000-07:00

SILVERLIGHT :
Ø A programming model for developing and distributing rich Internet applications (RIA) that use graphics, animations or video within the .NET framework. Silverlight was previously known by its code name, Windows Presentation Foundation
Ø Silverlight plug-in is both cross-browser and cross-platform Silverlight is based on the Microsoft .NET Framework and can be integrated with existing Web infrastructure and applications, including Apache and PHP, JavaScript and XHTML on the client. Using Silverlight, designers are able to prepare media for encoding and distribution, and create W3C standards-compliant sites.
Ø Silverlight is a new cross-browser, cross-platform implementation of the .NET Framework for building and delivering the next generation of media experiences and Rich Interactive Applications(RIA) for the web.
Ø It runs in all popular browsers, including Microsoft Internet Explorer, Mozilla Firefox, Apple Safari, Opera. The plugin required to run Silverlight is very small in size hence gets installed very quickly.
Ø It is combination of different technolgoies into a single development platform that allows you to select tools and the programming language you want to use.
Ø Silverlight integrates seamlessly with your existing Javascript and ASP.NET AJAX code to complement functionality which you have already created.
Ø Silverlight aims to compete with Adobe Flash and the presentation components of Ajax. It also competes with Sun Microsystems' JavaFX, which was launched a few days after Silverlight.
Currently there are 2 major versions of Silverlight:
Ø Silverlight 1.0 and Silverlight 2.0( previously referred to as version 1.1).
SILVERLIGHT 1.0:
Ø Silverlight 1.0, which was developed under the codename Windows Presentation Foundation/Everywhere (WPF/E), consists of the core presentation framework, which is responsible for UI, interactivity and user input, basic UI controls, graphics and animation, media playback, Digital rights management, and DOM integration.
Ø Silverlight 1.0 is purely AJAX and Javascript based. All the code has to be written in Javascript and XAML
Ø Silverlight 1.0 consists of the core presentation framework, which is responsible for UI, interactivity and user input, basic UI controls, graphics and animation, media playback, DRM support, and DOM integration.
Main features of Silverlight 1.0 :

Ø Built-in codec support for playing VC-1 and WMV video, and MP3 and WMA audio within a browser.
Ø Silverlight supports the ability to progressively download and play media content from any web-server.
Ø Silverlight also optionally supports built-in media streaming.
Ø Silverlight enables you to create rich UI and animations, and blend vector graphics with HTML to create compelling content experiences.
Ø Silverlight makes it easy to build rich video player interactive experiences.
SILVERLIGHT 2.0 :
Ø Silverlight 2 supports managed code. When Silverlight 2 runtime is installed, it installs a limited version of .NET runtime on the client machine. This allows .NET programmers to write managed code to be executed on the client PC and provide a better user experience to the users. Of course, there is security and restrictions built in to it so that the code has limited access to the client computer.
Ø Developers must be aware that if the end user decline to install the .NET runtime on their client computer, the Silverlight 2 applications will not run.
Ø Silverlight 2.0 includes a version of the .NET Framework, with the full Common Language Runtime as .NET Framework 3.0; so it can execute any .NET language including VB.NET and C# code.
Ø Unlike the CLR included with .NET Framework, multiple instances of the CoreCLR included in Silverlight can be hosted in one process.
Ø With this, the XAML layout markup file (.xaml file) can be augmented by code-behind code, written in any .NET language, which contains the programming logic.
Ø This version ships with more than 30 UI controls(including TextBox, CheckBox, Slider, ScrollViewer, and Calendar controls), for two-way databinding support, automated layout management (by means of StackPanel, Grid etc) as well as data-manipulation controls, such as DataGrid and ListBox. UI controls are skinnable using a template-based approach.
Main features of Silverlight 2.0 :
Ø A built-in CLR engine that delivers a super high performance execution environment for the browser. Silverlight uses the same core CLR engine that we ship with the full .NET Framework.
Ø Silverlight includes a rich framework library of built-in classes that you can use to develop browser-based applications.
Ø Silverlight includes support for a WPF UI programming model. The Silverlight 1.1 Alpha enables you to program your UI with managed code/event handlers, and supports the ability to define and use encapsulated UI controls.
Ø Silverlight provides a managed HTML DOM API that enables you to program the HTML of a browser using any .NET language.
Ø Silverlight doesn't require ASP.NET to be used on the backend web-server (meaning you could use Silverlight with with PHP on Linux if you wanted to).
Ø Silverlight 2 includes Deep Zoom, a technology derived from Microsoft Live Labs Seadragon. It allows users to zoom into, or out of, an image (or a collage of images), with smooth transitions, using the mouse wheel. The images can scale from 2 or 3 megapixels in resolution into the gigapixel range, but the user need not wait for it to be downloaded entirely; rather, Silverlight downloads only the parts in view, optimized for the zoom level being viewed.
Ø Silverlight 2 also allows limited filesystem access to Silverlight applications. It can use the operating system's native file dialog box to browse to any file (to which the user has access).
How Silverlight would change the Web:
Ø Highest Quality Video Experience : prepare to see some of the best quality videos you have seen in your life, all embedded in highly graphical websites. The same research and technology that was used for VC-1, the codec that powers BluRay and HD DVD, is used by Microsoft today with its streaming media technologies.
Ø Cross-Platform, Cross-Browser : Finally build web applications that work on any browser, and on any operating system. At release, Silverlight will work with Mac as well as Windows! The Mono project has also already promised support for Linux!.
Ø Developers and Graphic Designers can play together! : Developers familiar with Visual Studio, Microsoft.net will be able to develop amazing Silverlight applications very quickly, and they will work on Mac's and Windows. Developers will finally be able to strictly focus on the back end of the application core, while leaving the visuals to the Graphic Design team using the power of XAML.
Ø Cheaper : Silverlight is now the most inexpensive way to stream video files over the internet at the best quality possible. Licensing is dead simple, all you need is IIS in Windows Server, and you’re done.
Ø Support for 3rd Party Languages : Using the power of the new Dynamic Language Runtime, developers will now be able to use Ruby, Python, and EcmaScript! This means a Ruby developer can develop Silverlight applications, and leverage the .net Framework!
Ø Cross-Platform, Cross-Browser Remote Debugging : If you are in the need to debug an application running on a Mac, no problem! You can now set breakpoints, step into/over code, have immediate windows, and all that other good stuff that Visual Studio provides.
Ø The best development environment on the planet : Visual Studio is an award winning development platform! As it continues to constantly evolve, so will Silverlight!
Ø Silverlight offers copy protection : Have you noticed how easy it is to download YouTube videos to your computer, and save them for later viewing ? Silverlight will finally have the features enabling content providers complete control over their rich media content! Streaming television, new indie broadcast stations, all will now be possible!
Ø Extreme Speed :There is a dramatic improvement in speed for AJAX-enabled websites that begin to use Silverlight, leveraging the Microsoft .net framework.

Getting Started With SilverLight :
In order to create Silverlight applications with following :
Runtime :
Microsoft Silverlight 2.0 : The runtime required to view Silverlight applications created with .NET Microsoft.
Developer Tools :
Microsoft Visual Studio 8.0 : The next generation development tool.
Microsoft Silverlight Tools for Visual Studio 2008 : The add-on to create Silverlight applications with Visual Studio 2008. This install will also install the Silverlight Developer Runtime and the Silverlight SDK. This add-on works with all versions of Visual Studio 2008 Service Pack 1, including Visual Web Developer.
Designer Tools :
Download the Expression designer tools to start designing Silverlight application.
Expression Blend 2.5The latest offering from Microsoft to create Silverlight content is Expression Blend
Software Development Kit:
Microsoft Silverlight Software Development Kit: Download this SDK to create Silverlight Web experiences that target Silverlight 2.0. The SDK contains documentation, tools, Silverlight ASP.NET controls and the libraries needed to build Silverlight applications.
Eclipse Tools for Silverlight : An Open Source, feature-rich and professional RIA application development environment for Microsoft Silverlight in Eclipse.

2009-06-04T23:35:00.000-07:00

Diff bet Managed VS Unmanaged

2009-06-04T23:31:00.000-07:00

Ø Managed code is computer program code that executes under the management of a virtual machine,
Ø unlike unmanaged code, which is executed directly by the computer's CPU.
Ø The benefits of managed code include programmer convenience and enhanced security guarantees.
Ø The specific term managed code is most commonly used in connection with Microsoft's development environments, because Visual Studio is capable of compiling applications in both Managed and Unmanaged code.[1] [2] Microsoft's most common languages for creating managed code are C#, Visual Basic.NET and C++/CLI.
Ø Programs in any programming language could, in principle, be compiled into either managed or unmanaged code.
Ø Microsoft's Visual C++ development environment can produce both managed code (running under the .NET CLR)
Ø unmanaged code, running under the older MFC framework[2].

Ø Microsoft uses managed code in its CLR virtual machine in the .NET Framework, or another similar virtual machine.

CLOSING A SOCKET

2009-06-02T01:25:00.000-07:00

CLOSING A SOCKET
•Close the remote host connection and releases all managed and unmanaged resources associated with the socket.
Shutdown()
•To close a socket first call Shutdown() of Socket object .
•Shutdown() finalizes any pending operation on the socket and then signals the remote host at the end-point that the connection should be closed
close()
•The close() to close connection
If(s.Connected)
{
s. Shutdown() ;
s.Close();
}

RECEIVING DATA FROM A SOCKET

2009-06-02T01:21:00.000-07:00

RECEIVING DATA FROM A SOCKET
ØTo receive data from a socket ,use the ReceiveAsync() method
ØBegins an asynchronous request to receive data from a connected Socket object. \
ReceiveAsync()
ØNamespace: System.Net.SocketsAssembly: System.Net (in System.Net.dll)
C#
Øpublic bool ReceiveAsync( SocketAsyncEventArgs e)
STEPS
1.
ØCreate a byte array that can store data that is received on socket.
Øbyte[] response =new byte[1024];
2.
ØSet up the SocketAsyncEventArgs object that will be used to connect the socket to the remote host.
•SocketAsyncEventArgs arg = new SocketAsyncEventArgs();
arg.UserToken =s;
arg.RemoteEndPoint =ep;
3.
ØAttaching it to the SocketAsyncEventArgs object using SetBuffer()
ØSetBuffer accepts a byte array as 1st parameter,int offset as 2nd parameter and int length as 3rd parameter
•arg.SetBuffer(response,0, response.Lenth);
4.
ØOnReceivedCompleted() event handler to a SocketAsynEventArgs object
•arg.Completed+= new EventHandler
( OnReceivedCompleted);
5.
ØTo received data to remote host
ØReceivedAsync() method of the socket object and pass the SocketAsynEventArgs object
Øs. ReceivedAsync(arg);
6.
ØWhen data is received from the remote host the OnReceivedCompleted() event handler is called.

SENDING DATA ON A SOCKET

2009-06-01T23:33:00.000-07:00

SENDING DATA ON SOCKET
ØSends data asynchronously to a connected Socket object.
ØThe SendAsync method is used to write outgoing data from one or more buffers on a connection-oriented socket.
STEPS
1.
ØNamespace: System.Net.Sockets
Assembly: System.Net (in System.Net.dll)
C#
Øpublic bool SendAsync( SocketAsyncEventArgs args)
2.
ØSet up the SocketAsyncEventArgs object that will be used to connect the socket to the remote host.
•SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.UserToken =s;
args.RemoteEndPoint =ep;
3.
ØThe data is send on the socket by using encoding the data into a byte buffer
• Byte[] b = Encoding.UTF8.GetBytes(“My Data”);
4.
ØSetBuffer() function accepts a bytes array a byte array as 1st parameter,int offset as 2nd parameter ,and int length as 3rd parameter.
•args.SetBuffer(b,0, b.Lenth);
5.
ØOnSendCompleted() event handler to a SocketAsynEventArgs object
•args.Completed+= new EventHandler(OnSendCompleted);
6.
ØSendAsync() method of the socket object and pass the SocketAsynEventArgs object
•S.SendAsync(args);
7.
•When data is send to remote host the OnSendCompleted() event handler is called.

OPENING A SOCKET TO REMOTE HOST

2009-06-01T22:30:00.000-07:00

•STEPS
•1.Create an endpoint object that defines the address of the remote host
•Create DnsEndPoint object that points to port 4510 on host www.MySocketServer.com
•DnsEndPoint ep= new DnsEndPoint(www.MySocketServer.com,4510);
The DnsEndPoint class contains a host name or an IP address and remote port information needed by an application to connect to a service on a host. By combining the host name or IP address and port number of a service, the DnsEndPoint class forms a connection point to a service.
2.To create Socket Object use Constructor of Socket class .
ØSocket s = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,ProtocolType.Tcp);
Socket class Constructor takes three arguments
ØAddressFamily -Gets the Internet Protocol (IP) address family.
ØSocketType – Support only Stream
ØProtocolType - Support only TCP
3.Set up the SocketAsyncEventArgs object that will be used to connect the socket to the remote host.
ØSocketAsyncEventArgs sa = new SocketAsyncEventArgs();
sa.UserToken =s;
sa.RemoteEndPoint =ep;
4.Attact an event handler to handle the completed connection event
Øsa. Completed += new
EventHandler<>
(OnSocketConnectCompleted);
5.To open connection to remote host ,use
ConnectAsync() of socket object and pass the SocketAsyncEventArgs object
Øs. ConnectAsync(sa);

implementating socket in silverlight application

2009-06-01T22:18:00.000-07:00

SOCKET:
SOCKET are bidirectional that meaning either side of communication is capable for both sending and reciving data.
IMPLEMENTATION OF SOCKET IN SILVERLIGHT APPLICATIONS
System.Net.Sockets Manages:
ØSystem.Net.Sockets library provides real-time duplex communication .
ØThe System.Net.Sockets namespace added in Silverlight version 2 provides a managed implementation of the sockets networking interface for developers who need to tightly control access to the network.
ØSystem.Net.Sockets namespace provides a managed implementation of the Windows Sockets (Winsock) interface.
ØSystem.Net.Sockets namespace provides a managed implementation of the sockets interface based on Berkeley Software Distribution (BSD) UNIX.
SILVERLIGHT SOCKET FRAMEWORK
ØDnsEndPoint - Represents a network endpoint as a host name of an IP address and a port number.
ØEndPoint - Identifies a network address. This is an abstract class.
ØIPAddress - Provides an Internet Protocol (IP) address.
ØIPEndPoint - Represents a network endpoint as an IP address and a port number.
ØSocketAddress - Stores serialized information from EndPoint derived classes.
SOCKET CLASS
ØNamespace: System.Net.Sockets
Assembly: System (in System.dll)
DECLARATION :
Øpublic class Socket : IDisposable
ØThe Socket class provides a rich set of methods and properties for network communications.
ØThe Socket class allows you to perform both synchronous and asynchronous data transfer using any of the communication protocols listed in the ProtocolType enumeration
SOCKET CLASS IN SILVERLIGHT:
ØSocket communication in silverlight applications must be done asynchronously.
ØIn the Socket class, asynchronous socket operations are described by reusable System.Net.Sockets.SocketAsyncEventArgs objects allocated and maintained by the application.
SOCKET OBJECT METHOD :
ØConnectAsync - Starts an asynchronous request for a connection to the remote host.
ØSendAsync - Writes outgoing data from one or more buffers on a connected socket.
ØReceiveAsync - Reads incoming data into one or more buffers from a connected socket.
ØShutdown - Finishes any pending send operations, and signals the remote endpoint that the connection should be closed. If Send is specified, data may still be received until the remote computer closes its end of the connection (indicated by receiving 0 bytes).
ØClose - Closes the remote host connection and releases all managed and unmanaged resources associated with the socket.
DISADV OF SOCKET IN SILVERLIGHT 2.0:
ØThe port range that a network application is allowed to connect to must be within the range of 4502-4534. These are the only ports allowed for connection using sockets from silverlight 2 applications.
ØIf a connection is to a port is not within this port range, the connection attempt will fail.

diference between custom control and user control

2009-05-28T01:49:00.000-07:00

1) Custom controls are written in separate program files that are compiled explicitly and are persisted as an assembly (.dll).User controls are authored using the ASP.NET page syntax, either in the script block or in CodeBehind pages and are implicitly just-in-time compiled by the ASP.NET runtime system.
2) Custom Controls are nicely suited for general re-use as they are easy to package and redistribute as third-party controls. User Controls are best suited for reuse within a web application. Because they are persisted as source files, less chances exist that third parties would like to distribute them.
3) Once created, a custom control can be added to the toolbox of a visual designer, such as Visual Studio .NET, and dragged and dropped onto a page— just like any built-in server control. The visual designer can also support visual manipulation of custom control’s various properties.User controls provide minimal support for use with a visual designer toolbox.
4) A custom control provides minimal support for design-time authoring in a visual designer.A user control provides design-time support for authoring in a visual designer—just like an ASP.NET page.
5) A custom controls inherits System.Web.UI.Control or System.Web.UI.WebControls.WebControl class with class hierarchy (bottom up) either MyCustomControl.Control.Object OR MyCustomControl. WebControl.Control. Object.A user control inherits System.Web.UI.UserControl class with class hierarchy (bottom up) MyUserControl. UserControl. TemplateControl. Control. Object.
6) A custom control is in the form of dynamic linked library (.dll), thus pre-compiled.A user control has extension .ascx and is JIT compiled
7) A custom control does not have any design editor. It may or may not inherit functionality of other standard control(s). It can be an entirely new one.A user control must encapsulate functionality of other web server control(s) through dragging and dropping in design mode
.8 ) A custom control does not have design editor so is harder to create.A user control is easy to create because it can be designed like a page is designed i.e. they have design editor and code behind simultaneously
9) A custom control (newly created or extended) is a separate and pre-compiled component.A user control requires registration and instantiation per page and resides on a page as an object and is compiled along with the page. It is not in pre-compiled form
10) A custom control is more reusable because you do not need a separate copy of it for each application; it can automatically be loaded be from the GAC. Thus giving an advantage of being a framework wide component.A user control cannot be registered with Global Assembly Cache (GAC) .
11) A custom control’s class is not bound with any design. Here you can take the leverage of the flexibility and richness of .NET programming model; you can expose properties, override functions of the base class and also register complex client side logic in the class. A user control cannot provide the level of richness that a custom control can provide.
12) A custom control is the best choice especially when you want to make your controls redistributable, more reusable and make it a Visual Studio IDE aware component.A user control may fulfill your need if you are working on a single web application
13) A custom control cannot use the user control. A user control can use a custom control.
14) The custom control model is designed for authoring redistributable components in the form of an assembly (compiled class library) that can be used by a number of applications. The assembly containing the controls can be used by a single application at a time when placed in the application’s private bin directory, or it can be shared across multiple applications when placed into the global assembly cache, commonly referred to as the GAC. The assembly can be deployed and used in its compiled binary form without the associated source code.The user control model is designed for single-application scenarios. A user control is dynamically compiled at run time when a page that uses it is first requested. As a result, a user control must be deployed in source form, and the .ascx file (and its associated code-behind, if any exists) must be copied into every application that requires the user control.
15) Custom controls are authored by writing a managed class that derives directly or indirectly from System.Web.UI.Control in a .NET programming language.User controls are authored declaratively in the form of .ascx files, which is very similar to the way ASP.NET pages are designed and developed.

isolates storage

2009-05-11T03:13:00.000-07:00

Introduction
Many programmers use the config file to keep the application configuration data. But one disadvantage with this is, it is a read only mechanism. You cannot update data in application config files, using the ConfigurationSettings classes in .NET. In earlier days, .ini files or registry was used to save application specific data.
Of course, we can use regular files to save application data. But now the question is how to protect the data, where to save it and all other mess!
Isolated Storage
.NET introduces a concept called Isolated Storage. Isolated Storage is a kind of virtual folder. Users never need to know where exactly the file is stored. All you do is, tell the .NET framework to store your file in Isolated Storage. The physical location of Isolated Storage varies for each Operating System. But your application simply uses the .NET classes to create and access files, without bothering where it is physically located. And you can have Isolated Storage specific to each Assembly or each Windows user.
The following code sample demonstrates the basic create, write and read operations with Isolated Storage.
Make sure you include the following directives on top of your file:
using System.IO;
using System.IO.IsolatedStorage;
using System.Diagnostics;

System.IO.IsolatedStorage Namespace
The System.IO.IsolatedStorage namespace contains types for creating and using a virtual file system. Isolated storage provides safe client-side storage for partial-trust applications. In Silverlight, all I/O operations are restricted to isolated storage and do not use the file system of the operating system.
Classes
Class Description

IsolatedStorageException
The exception that is thrown when an operation in isolated storage fails.

IsolatedStorageFile
Represents an isolated storage area containing files and directories.

IsolatedStorageFileStream
Exposes a file within isolated storage.

Code sample:
const string ISOLATED_FILE_NAME = "MyIsolatedFile.txt";

//-------------------------------------------------------

// Check if the file already exists in isolated storage.

//-------------------------------------------------------

IsolatedStorageFile isoStore =
IsolatedStorageFile.GetStore( IsolatedStorageScope.User
| IsolatedStorageScope.Assembly, null, null );

string[] fileNames = isoStore.GetFileNames( ISOLATED_FILE_NAME );

foreach ( string file in fileNames )
{
if ( file == ISOLATED_FILE_NAME )
{
Debug.WriteLine("The file already exists!");
}
}

//-------------------------------------------------------

// Write some text into the file in isolated storage.

//-------------------------------------------------------

IsolatedStorageFileStream oStream =
new IsolatedStorageFileStream( ISOLATED_FILE_NAME,
FileMode.Create, isoStore );

StreamWriter writer = new StreamWriter( oStream );
writer.WriteLine( "This is my first line in the isolated storage file." );
writer.WriteLine( "This is second line." );
writer.Close();

//-------------------------------------------------------

// Read all lines from the file in isolated storage.

//-------------------------------------------------------

IsolatedStorageFileStream iStream =
new IsolatedStorageFileStream( ISOLATED_FILE_NAME,
FileMode.Open, isoStore );

StreamReader reader = new StreamReader( iStream );
String line;

while ( (line = reader.ReadLine()) != null )
{
Debug.WriteLine( line );
}

reader.Close();
Visit here to read my C# Tutorial collection.

License
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here
Silverlight Tip of the Day #19: Using Isolated Storage
Silverlight uses Isolated Storage as a virtual file system to store data in a hidden folder on your machine. It breaks up the data into two separate sections: Section #1 contains administrative information such as disk quota and section #2 contains the actual data. Each Silverlight application is allocated its own portion of the storage with the current quota set to be 1 MB per application.
Advantages:
1. Isolated Storage is a great alterative to using cookies (as discussed in Tip of the Day #18) especially if you are working with large sets of data. Examples of use include undo functionality for your app, shopping cart items, window settings and any other setting your application can call up the next time it loads.
2. Isolated storage stores by user allowing server applications to dedicate unique settings per individual user.
Possible Pitfalls:
1. Administrators can set disk quota per user and assembly which means there is no guarantee on space available. For this reason, it is important to add exception handling to your code.
2. Even though Isolated Storage is placed in a hidden folder it is possible, with a bit of effort, to find the folder. Therefore the data stored is not completely secure as users can change or remove files. It should be noted though that you can use the cryptography classes to the encrypt data stored in isolated storage preventing users from changing it.
3. Machines can be locked down by administrative security policies preventing applications from writing to the IsolatedStorage. More specifically, code must have the IsolatedStorageFilePermission to work with isolated storage.
All that said, let’s take a look at how we save and load data. Note that you will need to add a using statement to reference the namespace System.IO.IsolatedStorage as well as System.IO.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.IO.IsolatedStorage;
using System.IO;

namespace SilverlightApplication10
{
public partial class Page : UserControl
{
public Page()
{
InitializeComponent();
SaveData("Hello There", "MyData.txt");
string test = LoadData("MyData.txt");
}

private void SaveData(string data, string fileName)
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream isfs = new IsolatedStorageFileStream(fileName, FileMode.Create, isf))
{
using (StreamWriter sw = new StreamWriter(isfs))
{
sw.Write(data);
sw.Close();
}
}
}
}

private string LoadData(string fileName)
{
string data = String.Empty;
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream isfs = new IsolatedStorageFileStream(fileName, FileMode.Open, isf))
{
using (StreamReader sr = new StreamReader(isfs))
{
string lineOfData = String.Empty;
while ((lineOfData = sr.ReadLine()) != null)
data += lineOfData;
}
}
}
return data;
}
}
}

INI files and the Windows registry were a step in the right direction, but isolated storage is the best option for persisting application-specific user settings in .NET programs.
The question of where to store user-specific application settings has plagued developers since the dawn of the PC. Prior to Windows 3.1, applications typically stored settings in a configuration file in the application directory. Windows 3.1 introduced the concept of initialization (.INI) files, and their associated headaches—corruption of WIN.INI, INI droppings all over the Windows directory, and inadvertent corruption or deletion of other applications' INI files. The Win32 platform introduced the registry—a system-wide configuration database in which developers were encouraged to store application settings. However, it's a bad idea to store large amounts of data in the registry, and giving just anybody write access to the registry poses a serious security risk. The registry is a fine place to store application configuration data that system administrators control, but it's not a good place for user-specific application settings. In .NET programs, those settings belong in isolated storage.
What Is Isolated Storage?
According to the .NET definition, "Isolated storage is a storage mechanism that provides isolation and safety by defining standardized ways of associating code with saved data." The isolated storage subsystem standardizes access methods, provides security by preventing other programs and users from accessing application-specific data, and supplies tools that help system administrators configure and control the storage space. Isolated storage provides a standard, flexible, and (to an extent) secure location for an application to store its settings—a place where other applications can't inadvertently overwrite or delete.
How Isolated Is It?
Access to an isolated storage file is always restricted to the user who created the file. This setup prevents users from inadvertently overwriting or deleting application settings that were created by other users or programs. The .NET runtime uses the operating system user-identity mechanism to support this isolation. In addition to user isolation, storage can be isolated based on the assembly (a DLL that contains all kinds of .NET-specific stuff), or on the combined application domain and assembly. () By combining user, domain, and assembly, the .NET framework provides these two types of storage isolation:
• Isolation by user and assembly. Data isolated by user and assembly can be accessed only by the user who originally created it, and only from code that resides in a particular assembly. This type of isolation is useful if you have multiple applications that need to access the same configuration data for a particular user. If you create a separate assembly that accesses the isolated storage, any application that calls the assembly can access the data for that user.
• Isolation by user, domain, and assembly. Isolation by user, domain, and assembly is more restrictive. In addition to restricting access based on user and assembly, the runtime ensures that the only application that can access the data is the application that originally created it. This type of isolation prevents data leakage between applications, as well as data corruption by other applications.
When To Use Isolated Storage
With the few exceptions noted below, you should use isolated storage anytime you need to store user-specific application settings. These situations cover a wide range of possibilities:
• Downloaded controls. Controls downloaded from the Internet don't have permissions to access the file system, but they do have isolated storage permissions. Isolated storage is the only way that these controls can persist user-specific data without requiring that the system administrator grant more permissions to the code.
• Web application storage. Web applications have the same I/O limitations as downloaded controls, and so must use isolated storage for any kind of persistent data storage.
• Shared component storage. As I pointed out earlier, isolated storage is an ideal way to persist data between multiple applications that all use the same settings for a particular user.
• Standalone client application storage. Although standalone applications typically have full access to the file system and the registry, isolated storage is usually a better choice for user-specific settings because using it prevents inadvertent corruption of one user's data by another user. It also provides a standard location for settings, thereby making it easier to secure application directories.
• Server application storage. Server applications can impersonate the logged-in user to persist user-specific settings. This provides the same level of isolation for server applications as for standalone client applications, preventing data leakage between users.
• Roaming. Because isolated storage data is stored in a user's profile directory, enabling roaming profiles makes all of the user's application-specific storage available to that user, regardless of the computer on which the user is logged in.
Of course, there are a few situations in which you shouldn't use isolated storage:
• Storing high-value secrets. Don't use isolated storage to persist unencrypted keys or passwords, or other secret information. Isolated storage files are stored on disk (see the Microsoft documentation for the location), where they're vulnerable to snooping or corruption by unmanaged code, highly trusted code, and trusted computer users.
• Administrator settings. You shouldn't use isolated storage to persist configuration and deployment settings that are controlled by administrators.
Silverlight Isolated Storage Best Practices
When you use isolated storage, following these guidelines will help you avoid problems and make the most of the protection isolated storage provides.
• Wrap all calls to isolated storage within try/catch blocks to be resilient to potential IsolatedStorageExceptions, which can be thrown if isolated storage is disabled or if the store has been deleted.
• If your Silverlight application needs to store a lot of data in isolated storage, consider hosting it on its own site so that it won't affect other applications on the site and other applications won't affect it.
• If you have a group of Silverlight applications that need to share data on the client, host them on the same site.
• Keep isolated storage paths as small as possible to prevent the internal full path from reaching the 260-character limit.
• Encrypt sensitive data stored in isolated storage.
• Use IsolatedStorageSettings to store objects and simple settings in isolated storage.
• Use IsolatedStorageFile if you want to use file and stream-based APIs, are storing large amounts of data, or need fine-grained control over the contents of isolated storage

RIA

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

RICH INTERNET APPLICTION
A cross between browser-based Web applications and traditional desktop applications
BENEFITS OF RIA

Cost-effective way to deliver modern application with real business benefits
Provide real time data and inventory management.
Allow users to remotely monitor and manage data via a Web-based system.
Reduce data complexity -- allow users to interactively visualize and manipulate complex data more effectively and easily.
Provide immediate and dynamic visual feedback to the user.
Allow for quicker task completion.
Provide cross platform support.
FEATURES OF RIA
Run in a web browser, not requiring installation.
Run locally in a secure environment called a sandbox.
Users can use the application from any computer with an internet connection .
Cross-platform availability
Fast interface response time with no page refresh
Common UI behaviors like drag & drop and the ability to work online and offline
Common calculation that happens on the client (e.g., an insurance rate calculator)
Instant update of the application
RIA IN SILVERLIGHT
Any .Net programming language is used (c#, Ruby,Python,VB)
.Net based browser plug-in for rich features (animation,vector graphics and audio-video).
Silverlight is a great boost to the performance, providing a high-performance execution environment inside of the browser.
Silverlight enables applications that run within multiple browsers and operating systems (Windows and Macintosh) and built on web standards for pogrammability such as JavaScript, CSS and XML and the .NET CLR.
The CLR is the core piece of .NET Framework.
The CLR is a well-proven high-performance platform providing features like Garbage Collection, Just-In-Time compilation, Exception Management and a wide array of fully featured languages such as VB.NET and C# that are used
Applications
Financial Services
Auto Dealerships
Mortgage Firms
Customer survey forms
Email forms
Video Distribution (branding/licensing)
Remote training services
Customer service (live two-way video, chat )
Virtual Desktop Environments
CRM/ERP front-end applications

difference between silverlight 1.0 and silverlight 2.0

2009-05-06T03:00:00.000-07:00

SILVERLIGHT 1.0
l Cross-Browser Support for Firefox , Safari
l Cross-Platform Support for Windows and Mac (and Linux through the Moonlight Project)
l 2D Vector Animation/Graphics
l AJAX Support
l HTML DOM Integration
l HTTP Networking
l Canvas Layout Support
l Media –Image support like JPG,PNG.
l Media Markers
l Silverlight ASP.NET Controls (asp: media, asp:xaml)
l JavaScript Support
l XAML Parser (based on WPF)
l Media – 720P High Definition (HD) Video
l Media – Audio/Video Support (VC-1, WMV, WMA, MP3)
l Windows Media Server Support

SILVERLIGHT 2.0
l High quality resizing
l Media - Basic SSPL Support
l Cross Domain Network Access
l Easy access to server-side data via Web Services
l Direct access to TCP sockets
l Managed HTML Bridge
l Managed Exception Handling
l Rich Core Framework (e.g. Generics, collections)
l Support for Visual Basic.NET and C#; Common Language Runtime (CLR) based languages
l Support for IronPython, IronRuby, Managed JScript, and other Dynamic Language Runtime (DLR) based languages
l Multi-Threading
l Layout controls including StackPanel and Grid
l Full suite of Controls (TextBox, RadioButton, Slider, Calendar, DatePicker, DataGrid, ListBox, TabControl, and others)
l Managed Control Framework
l Templating Model
l Visual State Manager
l Isolated Storage
l Deep Zoom Technology
l Media – DRM Powered by PlayReady
l Media - Windows Media Audio 10 Professional support
l Direct access to TCP sockets
l Media - MediaStreamSource for managed code media file parser and protocol extensibility
l Interoperability with SOAP and REST services, including support for XML, JSON, RSS and Atom data formats
l LINQ (including LINQ to XML, LINQ to JSON, and LINQ to Entities)
l Duplex communications (“push” from Server to Silverlight client)
l Data Binding
l ADO.NET Data Services
l .NET Framework Security Enforcement
l Type Safety Verification
l XMLReader/Writer
l Enhanced Keyboard Input Support
l File Upload Support (via WebClient API)
l WPF Compatibility
l Accessibility
l Localization
l Remote Debugging (PC and Mac)

RIA

2009-05-04T02:11:00.000-07:00

RICH INTERNET APPLICTION :
Rich Internet Application is a web application resembling the features of a desktop application It provides an end user experience similar to client/server applications supported by rich graphical user interface.
BENEFITS OF RIA :
RIA offers organizations a proven, cost-effective way to deliver modern application with real business benefits
Ø Offer users a richer, more engaging experience
Ø Keep pace with users' rising expectations
Ø Increase customer loyalty and generate higher profits.
Ø Leverage existing personnel ,processes ,and infrastructure.
Ø Highly responsive performance and reduced network load.
Ø Higher, richer and easier levels of interactive functionality.
BENEFITS OF RIA IN SILVERLIGHT :
The emergence of new technologies such Silverlight not only take performance management to the next level, but also enables the user to benefit from 'rich' UI and enhanced performance at the same time. These technologies facilitate the users in various ways
Ø A technology widely known as 'no-refresh', where the transition from one set of information to another is instantaneous and visually more appealing
Ø No major installation required. Updating and distributing the application is an instant and automatic process
Ø Users can use the application from any computer equipped with an Internet connection regardless of the operating system running on that computer
Ø Web-based applications are generally less prone to viral infections contrary to the desktop applications

wpf

2009-04-28T03:23:00.000-07:00

Difference between component and controls in silverlight :
Component is a class that implements the System.ComponentModel.IComponent interface or that derives directly or indirectly from a class that implements IComponent. In programming, the term component is generally used for an object that is reusable and can interact with other objects. A .NET Framework component satisfies those general requirements and additionally provides features such as control over external resources and design-time support.Design-Time SupportHosting a ComponentMarshaling a ComponentControlA control is a component that provides (or enables) user-interface (UI) capabilities. The .NET Framework provides two base classes for controls: one for client-side Windows Forms controls and the other for ASP.NET server controls. These are System.Windows.Forms.Control and System.Web.UI.Control. All controls in the .NET Framework class library derive directly or indirectly from these two classes. System.Windows.Forms.Control derives from Component and itself provides UI capabilities. System.Web.UI.Control implements IComponent and provides the infrastructure on which it is easy to add UI functionalityEvery control is a component, but the converse is not trueA container is a class that implements the System.ComponentModel.IContainer interface or derives from a class that implements this interface. A container logically contains one or more components that are called the container's child components.A site is a class that implements the System.ComponentModel.ISite interface or derives from a class that implements this interface. Sites are provided by a container to manage and communicate with its child components. Typically, a container and a site are implemented as a unit.

Windows Presentation Foundation (WPF)
Windows Presentation Foundation (WPF) provides a unified framework for building applications and high-fidelity experiences in Windows Vista that blend together application UI, documents, and media content, while exploiting the full power of the computer.
Provides classes for building UI, documents, and media
Use a single WPF programming model to write code once and deploy it as a standalone installed application or in a browser.
WPF features include:
v Client Profile enables faster redistribution with a smaller download
Ø 2D and 3D graphics and hardware accelerated effects
Ø Common file format (XAML) allowing designers and developers to collaborate
Ø Scalability to different form factors
Ø Controls, data binding and extensibility enable developers to quickly build high fidelity applications
Differences between WPF and Silverlight :
The binding system in WPF also supports input validation which is not offered in Silverlight. In WPF you can use the IDataErrorInfo interface. Another important difference between the two systems is that Silverlight does not support commands which will allow the view to directly consume the ViewModel functionality

silverlight

2009-04-28T03:01:00.000-07:00

SILVERLIGHT 2.0 :
Cross Platform / Cross Browser .NET Development
Silverlight 2 includes a cross-platform, cross-browser version of the .NET Framework, and enables a rich .NET development platform that runs in the browser. Developers can write Silverlight applications using any .NET language (including VB, C#, JavaScript, IronPython and IronRuby). We will ship Visual Studio 2008 and Expression Studio tool support that enables great developer / designer workflow and integration when building Silverlight applications.
This upcoming Beta1 release of Silverlight 2 provides a rich set of features for RIA application development. These include:
WPF UI Framework: Silverlight 2 includes a rich WPF-based UI framework that makes building rich Web applications much easier. In includes a powerful graphics and animation engine, as well as rich support for higher-level UI capabilities like controls, layout management, data-binding, styles, and template skinning. The WPF UI Framework in Silverlight is a compatible subset of the WPF UI Framework features in the full .NET Framework, and enables developers to re-use skills, controls, code and content to build both rich cross browser web applications, as well as rich desktop Windows applications.
Rich Controls: Silverlight 2 includes a rich set of built-in controls that developers and designers can use to quickly build applications. This upcoming Beta1 release includes core form controls (TextBox, CheckBox, RadioButton, etc), built-in layout management panels (StackPanel, Grid, Panel, etc), common functionality controls (Slider, ScrollViewer, Calendar, DatePicker, etc), and data manipulation controls (DataGrid, ListBox, etc). The built-in controls support a rich control templating model, which enables developers and designers to collaborate together to build highly polished solutions.

Rich Networking Support: Silverlight 2 includes rich networking support. It includes out of the box support for calling REST, WS*/SOAP, POX, RSS, and standard HTTP services. It supports cross domain network access (enabling Silverlight clients to directly access resources and data from resources on the web). Beta1 also includes built-in sockets networking support.
Rich Base Class Library: Silverlight 2 includes a rich .NET base class library of functionality (collections, IO, generics, threading, globalization, XML, local storage, etc). It includes rich APIs that enable HTML DOM/JavaScript integration with .NET code. It also includes LINQ and LINQ to XML library support (enabling easy transformation and querying of data), as well as local data caching and storage support. The .NET APIs in Silverlight are a compatible subset of the full .NET Framework.

>> Silverlight 2 does not require the .NET Framework to be installed on a computer in order to run. The Silverlight setup download includes everything necessary to enable all the above features (and more we'll be talking about shortly) on a vanilla Mac OSX or Windows machine.
>>The Beta1 release of Silverlight 2 is 4.3MB in size, and takes 4-10 seconds to install on a machine that doesn't already have it. Once Silverlight 2 is installed you can browse the Web and automatically run rich Silverlight applications within your browser of choice (IE, FireFox, Safari, etc).
>>NET Framework 3.0 combines ASP.NET 2.0 and the .NET Framework 2.0 APIs with new technologies for building a broader range of applications, which include those listed below:

Some Key Silverlight 2.0 Features :
.NET Framework Support - A rich base class library. Silverlight 2 supports C#, JavaScript, and Visual Basic..etc.
Deep zoom - Enables ultrahigh resolution imagery.
Built-In Controls - These include Calendar, DataGrid, ListBox, ScrollViewer, Slider controls..etc.
Skinning and Templating - Customize the look and feel of your application.
Advertiser Support - Includes streaming and progressive download capabilities, enhanced search engine optimization techniques, and in-stream advertising support.
Content Protection - Includes Silverlight DRM (powered by PlayReady) for robust content protection.
Silverlight Architecture
Silverlight is not only an appealing canvas for displaying rich and interactive Web and media content to end users. It is also a powerful yet lightweight platform for developing portable, cross-platform, networked applications that integrate data and services from many sources. Furthermore, Silverlight enables you to build user interfaces that will significantly enhance the typical end user experience compared with traditional Web applications.
While Silverlight as a client-side runtime environment seems simple and compact in size, the Silverlight development platform integrates a number of features and complex technologies, making them accessible for developers. To create effective Silverlight-based applications, developers need a working knowledge of the platform architecture.
There is a particular value in the combined set of tools, technologies, and services included in the Silverlight platform: They make it easier for developers to create rich, interactive, and networked applications. Although it is certainly possible to build such applications using today's Web tools and technologies, developers are hindered by many technical difficulties, including incompatible platforms, disparate file formats and protocols, and various Web browsers that render pages and handle scripts differently.
A rich Web application that runs perfectly on one system and browser may work very differently on another system or browser, or may fail altogether. Array of tools, protocols, and technologies, it is a massive and often cost-prohibitive effort to build an application that can simultaneously provide the following advantages:
· Ability to create the same user experience across browsers and platforms, so that the application looks and performs the same everywhere.
· Integration of data and services from multiple networked locations into one application using familiar .NET Framework classes and functionality.
· A media-rich, compelling, and accessible user interface (UI).
· Silverlight makes it easier for developers to build such applications, because it overcomes many of the incompatibilities of current technologies, and provides within one platform the tools to create rich, cross-platform, integrated applications.
Core Presentation Features of Silverlight
Input => Handles inputs from hardware devices such as the keyboard and mouse, drawing, or other input devices.
UI rendering=> Renders vector and bitmap graphics, animations, and text.
Media => Features playback and management of various types of audio and video files, such as .WMP and .MP3 files.
Controls =>Supports extensible controls that are customizable through styling and templating.
Layout =>Enables dynamic positioning of UI elements.
Data binding =>Enables linking of data objects and UI elements.
DRM =>Enables digital rights management of media assets.
XAML =>Provides a parser for XAML markup.
Developers can interact with this presentation framework by using XAML to specify presentation details. XAML is the primary point of interaction between the .NET Framework and the presentation layer
The .NET Framework for Silverlight features
Data => Supports Language-Integrated Query (LINQ) and LINQ to XML features, which ease the process of integrating and working with data from disparate sources. Also supports the use of XML and serialization classes for handling data.
Base class library => A set of .NET Framework libraries that provide essential programming functions, such as string handling, regular expressions, input and output, reflection, collections, and globalization.
Window Communication Foundation (WCF) => Provides features to simplify access to remote services and data. This includes a browser object, HTTP request and response object, support for cross-domain HTTP requests, support for RSS/Atom syndication feeds, and support for JSON, POX, and SOAP services.
CLR (common language runtime)=>Provides memory management, garbage collection, type safety checking, and exception handling.
WPF (Windows Presentation Foundation) controls=>Provides a rich set of controls, including Button, Calendar, CheckBox, DataGrid, DatePicker, HyperlinkButton, ListBox, RadioButton, and ScrollViewer.
DLR (dynamic language runtime) =>Supports the dynamic compilation and execution of scripting languages such as JavaScript and IronPython to program Silverlight-based applications. Includes a pluggable model for adding support for other languages for use with Silverlight.
Developers can interact with the .NET Framework for Silverlight layer by writing managed code using C# and Visual Basic. .NET Framework developers can also access the presentation layer by authoring in Visual Studio 2008 or Microsoft Expression Blend.
Additional Silverlight Programming Features
Isolated storage is Provides safe access from the Silverlight client to the local computer's file system. Enables local storage and caching of data isolated to a particular user.
Asynchronous programming is a background worker thread carries out programming tasks while the application is freed up for user interaction.
File management isProvides a safe File Open dialog box, to ease the process of creating safe file uploads.
HTML–managed code interaction is enables .NET Framework programmers to directly manipulate UI elements in the HTML DOM of a Web page. Web developers can also use JavaScript to call directly into managed code and access scriptable objects, properties, events, and methods.
Serialization is provides support for serialization of CLR types to JSON and XML.
Packaging is provides the Application class and build tools to create .xap packages. The .xap package contains the application and entry point for the Silverlight plug-in control to run.
XML libraries is XmlReader and XmlWriter classes simplify working with XML data from Web services. The XLinq feature enables developers to query XML data directly within .NET Framework programming languages.
The following Microsoft applications include special features for Silverlight development:
· Microsoft Expression Blend. This tool can be used to create and modify the presentation layer of an application by manipulating the XAML canvas and controls, working with graphics, and programming the presentation layer with a dynamic language such as JavaScript.
· Visual Studio 2008. Visual Studio provides productivity tools for developing applications using managed code. All the existing features of Visual Studio are available for Silverlight. In addition, this version of Visual Studio includes Silverlight-specific features, including IntelliSense, debugging, and Silverlight project templates that create and link all required files.

benefits of dnn

2009-04-16T03:24:00.000-07:00

The multiple portal feature in DotNetNuke is one of its most powerful.
Easy Web site administration: While working on this framework no programming knowledge is required. Clients can generate, supervise and publish web content without requiring any technical skill level.
Ready to use: DotNetNuke is user-friendly framework and is built in such a way as to allow users to deal with all parts of their projects. A well worked out user interface allows an easy operation.
Advanced Features: The advanced features in DotNetNuke exceed the features in your homegrown applications. Moreover it is a constantly evolving with multi-functionality to cater end-user requirements. It also saves development time.
Strength: The administrative options are skillfully divided between host level and individual portal level. In one hosting account the administrator at DotNetNuke supports multiple portals or sites- each with its own look.
Powerful Tools: DotNetNuke comes with a set of powerful tools. These built in tools provide multi-functionality for security, site designing, hosting, site membership options etc. There are various other features that can be manipulated as per your needs with these tools.
Network of Support: A Core Team of developers is always there to support DotNetNuke. Online Forums, blogs, online help and various websites give DotNetNuke a dedicated network of support.
Easy Installation: DotNetNuke.com provides the free download software and an install.pdf with install instructions for the latest version of DotNetNuke. DotNetNuke can be made running within minutes.¼LI>Multi-Language Localization: DotNetNuke supports a multi-language localization that allows the websites built on it, to be translated into any language.
Licensed Open Source Software: DotNetNuke 3.0 is available for free download. The full application source code and sub-projects are distributed under a standard BSD open source license; providing the maximum freedom in both non-commercial and commercial environments.
Increase Profits Opportunities: DotNetNuke is module based. So you can build up various unique modules and sell them to your clients. Besides this, you can also go commercial with site templates, database options etc.
Latest Technology: The working of DotNetNuke utilizes modern day technology- ASP.NET 2.0, Visual Web Developer, Visual Studio 2005 and SQL Server 2005, thus giving the users a hands on to the latest technology.
Advanced CMS: DotNetNuke has built-in tools to create the most complex content management systems. Moreover, many options of extending and customizing the site are also available.
Established: DotNetNuke is a now a trademark in web designing. It is a popular brand in the open source community. With over 250,000 registered users and a talented team of developers. Through end-user feedback and real world trial DotNetNuke continues to grow.
Easy to integrate: With its flexible infrastructure, DotNetNuke is easy to integrate within your conventional processes.
Priority on security: Emphasis placed on validation, encryption, “bug” tracking and potential threats provides a secure way to build websites.
Fully customizable: Changes can be made to portals at all levels – from basic stylesheet elements like font type, color, and bullet points, to overall site appearance. New skins and module containers can be easily applied to the site with no repercussion on content.
The benefits of DotNetNuke for hosters include:
DotNetNuke is browser based content management system. It simplifies web site management by letting the clients, regardless of their skill; decide the infrastructure and content of the site.
No Developers, no programmers needed. So a working website is developed quite fast.
A client can easily make changes in website without any support. So content authoring, deployment, and configuration support is not required hence reducing costs of maintaining a website.
DotNetNuke separates site content from site design so extremely customized site templates can be provided for your clients.
DotNetNuke is an advanced and constantly evolving technology. It is versatile, user friendly and has an international community to support thus saves your valuable development time and expenses.
Leverage existing investments: DotNetNuke is built on Microsoft technology, including the .NET Framework so it leverages your existing investments such as Windows servers, database servers, and development tools.
It simplifies internal management processes, and makes your hosting packages more attractive and valuable. With an active open source community and more than 150,000 registered users worldwide, DotNetNuke is loved by Hosters.

2009-04-15T03:23:00.001-07:00

DotNetNuke:
DotNetNuke is a development framework that enables businesses to quickly build and deploy feature-rich, interactive websites and applications in Microsoft environments. Through an intuitive, menu-driven interface, even non-technical users can use DotNetNuke to easily create new sites or extend the functionality and features of existing web applications.
DotNetNuke evolved from a project called the IBuySpyWorkshop (IBSW.) It was renamed to DotNetNuke to avoid confusion with Microsoft’s portal starter kit, known as IBuySpy Portal. The new name was chosen to reflect the applications .NET (DOTNET) framework, and coupled with the term “nuke” (due to *nuke’s inherent, industry-recognized inclusion in several existing open source portal initiatives.)Professional and Community Editions DNN Corp. offers Professional and Community Editions of DotNetNuke based on the same widely adopted and exhaustive ely tested code base and backed by the same thriving open source community of users, developers, integrators, and vendors. Both Editions are powerful, easy to use, and nearly infinitely scalable.
DotNetNuke Professional Edition is the “certified” version of DotNetNuke Community Edition. In addition to all of the features and functionality of the Community Edition, DotNetNuke Professional Edition includes same-day product support, performance guarantees, and copyright guarantees to ensure indemnification, making it the perfect solution for organizations that intend to use the framework as a core element of their mission-critical web-based communications strategies.
DotNetNuke Community Edition, available for download free of charge, is widely used by administrators who don’t require the additional commercial features available in Professional Edition. Moving from Community Edition to Professional Edition requires no code modification or re-installation

dotnetnuke

2009-04-15T03:21:00.000-07:00

2009-04-08T02:53:00.000-07:00

Today i have created ppt for silverlight ,webservies,RIA,control,components and i search component with that i tred web services code .

srilatha

2009-04-08T01:38:00.000-07:00

difeernce between silverlight &wpf :
The binding system in WPF also supports input validation which is not offered in Silverlight. In WPF you can use the IDataErrorInfo interface. Another important difference between the two systems is that Silverlight does not support commands which will allow the view to directly consume the ViewModel functionality.

silverlight

2009-04-08T00:25:00.001-07:00

SILVERLIGHT 1.0 :Silverlight 1 is purely AJAX and Javascript based. All the code has to be written in Javascript and XAML.Silverlight 1.0, which was developed under the codename Windows Presentation Foundation/Everywhere (WPF/E), consists of the core presentation framework, which is responsible for UI, interactivity and user input, basic UI controls, graphics and animation, media playback, Digital rights management, and DOM integrationSILVERLIGHT 2.0 :Silverlight 2 supports managed code. When Silverlight 2 runtime is installed, it installs a limited version of .NET runtime on the client machine. This allows .NET programmers to write managed code to be executed on the client PC and provide a better user experience to the users. Of course, there is security and restrictions built in to it so that the code has limited access to the client computer.Developers must be aware that if the end user decline to install the .NET runtime on their client computer, the Silverlight 2 applications will not run.

Rich Internet Application

2009-04-08T00:22:00.000-07:00

RIAs offer organizations a proven, cost-effective way to deliver modern applications with real bussiness benifit likeOffer users a richer, more engaging experience,
Keep pace with users' rising expectations,Increase customer loyalty and generate higher profits.
Leverage existing personnel, processes, and infrastructure.

srilatha

2009-04-06T21:42:00.000-07:00

Web Services - a standards based suite of technologies (XML, SOAP, WSDL, UDDI) designed to support interoperable applications to application interactions over a network.
and some of url for web servies i searched few are given below
http://provost.uiowa.edu/maui/Glossary.html http://www.looselycoupled.com/glossary/web%20services http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci750567,00.html http://www.jianway.co.uk/articles/web-definitions-20081020.htmlcoding part examplehttp://blogs.msdn.com/silverlight_sdk/archive/2008/03/27/web-services-and-silverlight.aspx

web services

2009-04-03T02:24:00.000-07:00

Web services:
Web services let computers talk to one another over the Internet, allowing computer programs to exchange information by eliminating barriers such as different hardware platforms, software languages, and operating systems that usually make different programs incompatible. Web services make it easier to share information, data, and services, as well as making it cheaper and easier for businesses to work with on-line partners. This technology will help to increase e-business.