Code Library

HBASE DISTRIBUTED STORAGE ARCHITECTURE

2012-02-10T23:19:00.000+08:00

A robust HBase architecture involves a few more parts than HBase alone. At the very least, an underlying distributed, centralized service for confi guration and synchronization is involved. HBase deployment adheres to a master-worker pattern. Therefore, there is usually a master and a set of workers, commonly known as range servers. When HBase starts, the master allocates a set of ranges to a range server. Each range stores an ordered set of rows, where each row is identifi ed by a unique row-key. As the number of rows stored in a range grows in size beyond a confi gured threshold, the range is split into two and rows are divided between the two new ranges.

Like most column-databases, HBase stores columns in a column-family together. Therefore, each region maintains a separate store for each column-family in every table. Each store in turn maps to a physical fi le that is stored in the underlying distributed fi lesystem. For each store, HBase abstracts access to the underlying fi lesystem with the help of a thin wrapper that acts as the intermediary between the store and the underlying physical fi le.

Each region has an in-memory store, or cache, and a write-ahead-log (WAL). To quote Wikipedia, http://en.wikipedia.org/wiki/Write-ahead_logging, “write-ahead logging (WAL) is a family of techniques for providing atomicity and durability (two of the ACID properties) in database systems.” WAL is a common technique used across a variety of database systems, including the popular relational database systems like PostgreSQL and MySQL. In HBase a client program could decide to turn WAL on or switch it off. Switching it off would boost performance but reduce reliability and recovery, in case of failure. When data is written to a region, it’s fi rst written to the write-ahead-log, if enabled. Soon afterwards, it’s written to the region’s in-memory store. If the in-memory store is full, data is fl ushed to disk and persisted in the underlying distributed storage.

If a distributed fi lesystem like the Hadoop distributed fi lesystem (HDFS) is used, then a masterworker pattern extends to the underlying storage scheme as well. In HDFS, a namenode and a set of datanodes form a structure analogous to the confi guration of master and range servers that column databases like HBase follow. Thus, in such a situation each physical storage fi le for an HBase column-family store ends up residing in an HDFS datanode. HBase leverages a fi lesystem API to avoid strong coupling with HDFS and so this API acts as the intermediary for conversations between an HBase store and a corresponding HDFS fi le. The API allows HBase to work seamlessly with other types of fi lesystems as well. For example, HBase could be used with CloudStore, formerly known as Kosmos FileSystem (KFS), instead of HDFS.

In addition to having the distributed fi lesystem for storage, an HBase cluster also leverages an external confi guration and coordination utility. In the seminal paper on Bigtable, Google named this confi guration program Chubby. Hadoop, being a Google infrastructure clone, created an exact counterpart and called it ZooKeeper. Hypertable calls the similar infrastructure piece Hyperspace. A ZooKeeper cluster typically front-ends an HBase cluster for new clients and manages confi guration.

To access HBase the fi rst time, a client accesses two catalogs via ZooKeeper. These catalogs are named -ROOT- and .META. The catalogs maintain state and location information for all the regions. -ROOT- keeps information of all .META. tables and a .META. fi le keeps records for a user-space table, that is, the table that holds the data. When a client wants to access a specifi c row it first asks ZooKeeper for the -ROOT- catalog. The -ROOT- catalog locates the .META. catalog relevant for the row, which in turn provides all the region details for accessing the specifi c row. Using this information the row is accessed. The three-step process of accessing a row is not repeated the next time the client asks for the row data. Column databases rely heavily on caching all relevant information, from this three-step lookup process. This means clients directly contact the region servers the next time they need the row data. The long loop of lookups is repeated only if the region information in the cache is stale or the region is disabled and inaccessible.

Each region is often identifi ed by the smallest row-key it stores, so looking up a row is usually as easy as verifying that the specifi c row-key is greater than or equal to the region identifi er.

So far, the essential conceptual and physical models of column database storage have been introduced. The behind-the-scenes mechanics of data write and read into these stores have also been exposed.

Source of Information : NoSQL

Case Studies of some Platform as Service (PaaS) offerings.

2012-02-07T23:03:00.000+08:00

Aneka. Aneka is a .NET-based service-oriented resource management and development platform. Each server in an Aneka deployment (dubbed Aneka cloud node) hosts the Aneka container, which provides the base infrastructure that consists of services for persistence, security (authorization, authentication and auditing), and communication (message handling and dispatching). Cloud nodes can be either physical server, virtual machines (XenServer and VMware are supported), and instances rented from Amazon EC2.

The Aneka container can also host any number of optional services that can be added by developers to augment the capabilities of an Aneka Cloud node, thus providing a single, extensible framework for orchestrating various application models.

Several programming models are supported by such task models to enable execution of legacy HPC applications and MapReduce, which enables a variety of data-mining and search applications.

Users request resources via a client to a reservation services manager of the Aneka master node, which manages all cloud nodes and contains scheduling service to distribute request to cloud nodes.

App Engine. Google App Engine lets you run your Python and Java Web applications on elastic infrastructure supplied by Google. App Engine allows your applications to scale dynamically as your traffic and data storage requirements increase or decrease. It gives developers a choice between a Python stack and Java. The App Engine serving architecture is notable in that it allows real-time auto-scaling without virtualization for many common types of Web applications. However, such auto-scaling is dependent on the application developer using a limited subset of the native APIs on each platform, and in some instances you need to use specific Google APIs such as URLFetch, Datastore, and memcache in place of certain native API calls. For example, a deployed App Engine application cannot write to the file system directly (you must use the Google Datastore) or open a socket or access another host directly (you must use Google URL fetch service). A Java application cannot create a new Thread either.

Microsoft Azure. Microsoft Azure Cloud Services offers developers a hosted . NET Stack (C#, VB.Net, ASP.NET). In addition, a Java & Ruby SDK for .NET Services is also available. The Azure system consists of a number of elements. The Windows Azure Fabric Controller provides auto-scaling and reliability, and it manages memory resources and load balancing. The .NET Service Bus registers and connects applications together. The .NET Access Control identity providers include enterprise directories and Windows LiveID. Finally, the .NET Workflow allows construction and execution of workflow instances.

Force.com. In conjunction with the Salesforce.com service, the Force.com PaaS allows developers to create add-on functionality that integrates into main Salesforce CRM SaaS application. Force.com offers developers two approaches to create applications that can be deployed on its SaaS plaform: a hosted Apex or Visualforce application. Apex is a proprietary Java-like language that can be used to create Salesforce applications. Visualforce is an XML-like syntax for building UIs in HTML, AJAX, or Flex to overlay over the Salesforce hosted CRM system. An application store called AppExchange is also provided, which offers a paid & free application directory.

Heroku. Heroku is a platform for instant deployment of Ruby on Rails Web applications. In the Heroku system, servers are invisibly managed by the platform and are never exposed to users. Applications are automatically dispersed across different CPU cores and servers, maximizing performance and minimizing contention. Heroku has an advanced logic layer than can automatically route around failures, ensuring seamless and uninterrupted service at all times.

Source of Information : Wiley - Cloud Computing Principles and Paradigms 2011

Source of information :

PLATFORM AS A SERVICE PROVIDERS

2012-02-04T22:49:00.000+08:00

Public Platform as a Service providers commonly offer a development and deployment environment that allow users to create and run their applications with little or no concern to low-level details of the platform. In addition, specific programming languages and frameworks are made available in the platform, as well as other services such as persistent data storage and inmemory caches.

Programming Models, Languages, and Frameworks. Programming models made available by IaaS providers define how users can express their applications using higher levels of abstraction and efficiently run them on the cloud platform. Each model aims at efficiently solving a particular problem. In the cloud computing domain, the most common activities that require specialized models are: processing of large dataset in clusters of computers (MapReduce model), development of request-based Web services and applications; definition and orchestration of business processes in the form of workflows (Workflow model); and high-performance distributed execution of various computational tasks. For user convenience, PaaS providers usually support multiple programming languages. Most commonly used languages in platforms include Python and Java (e.g., Google AppEngine), .NET languages (e.g., Microsoft Azure), and Ruby (e.g., Heroku). Force.com has devised its own programming language (Apex) and an Excel-like query language, which provide higher levels of abstraction to key platform functionalities. A variety of software frameworks are usually made available to PaaS developers, depending on application focus. Providers that focus on Web and enterprise application hosting offer popular frameworks such as Ruby on Rails, Spring, Java EE, and .NET.

Persistence Options. A persistence layer is essential to allow applications to record their state and recover it in case of crashes, as well as to store user data. Traditionally, Web and enterprise application developers have chosen relational databases as the preferred persistence method. These databases offer fast and reliable structured data storage and transaction processing, but may lack scalability to handle several petabytes of data stored in commodity computers.

In the cloud computing domain, distributed storage technologies have emerged, which seek to be robust and highly scalable, at the expense of relational structure and convenient query languages. For example, Amazon SimpleDB and Google AppEngine datastore offer schema-less, automatically indexed database services. Data queries can be performed only on individual tables; that is, join operations are unsupported for the sake of scalability.

Source of Information : Wiley - Cloud Computing Principles and Paradigms 2011

Case Studies of the most popular public IaaS clouds

2012-01-31T22:29:00.000+08:00

Amazon Web Services. Amazon WS4 (AWS) is one of the major players in the cloud computing market. It pioneered the introduction of IaaS clouds in 2006. It offers a variety cloud services, most notably: S3 (storage), EC2 (virtual servers), Cloudfront (content delivery), Cloudfront Streaming (video streaming), SimpleDB (structured datastore), RDS (Relational Database), SQS (reliable messaging), and Elastic MapReduce (data processing).
The ElasticCompute Cloud (EC2) offers Xen-based virtual servers (instances) that can be instantiated from Amazon Machine Images (AMIs). Instances are available in a variety of sizes, operating systems, architectures, and price. CPU capacity of instances is measured in Amazon Compute Units and, although fixed for each instance, vary among instance types from 1 (small instance) to 20 (high CPU instance). Each instance provides a certain amount of nonpersistent disk space; a persistence disk service (Elastic Block Storage) allows attaching virtual disks to instances with space up to 1TB.

Elasticity can be achieved by combining the CloudWatch, Auto Scaling, and Elastic Load Balancing features, which allow the number of instances to scale up and down automatically based on a set of customizable rules, and traffic to be distributed across available instances. Fixed IP address (Elastic IPs) are not available by default, but can be obtained at an additional cost.

In summary, Amazon EC2 provides the following features: multiple data centers available in the United States (East and West) and Europe; CLI, Web services (SOAP and Query), Web-based console user interfaces; access to instance mainly via SSH (Linux) and Remote Desktop (Windows); advanced reservation of capacity (aka reserved instances) that guarantees availability for periods of 1 and 3 years; 99.5% availability SLA; per hour pricing; Linux and Windows operating systems; automatic scaling; load balancing.

Flexiscale. Flexiscale is a UK-based provider offering services similar in nature to Amazon Web Services. However, its virtual servers offer some distinct features, most notably: persistent storage by default, fixed IP addresses, dedicated VLAN, a wider range of server sizes, and runtime adjustment of CPU capacity (aka CPU bursting/vertical scaling). Similar to the clouds, this service is also priced by the hour.

In summary, the Flexiscale cloud provides the following features: available in UK; Web services (SOAP), Web-based user interfaces; access to virtual server mainly via SSH (Linux) and Remote Desktop (Windows); 100% availability SLA with automatic recovery of VMs in case of hardware failure; per hour pricing; Linux and Windows operating systems; automatic scaling (horizontal/vertical).

Joyent. Joyent’s Public Cloud offers servers based on Solaris containers virtualization technology. These servers, dubbed accelerators, allow deploying various specialized software-stack based on a customized version of Open- Solaris operating system, which include by default a Web-based configuration tool and several pre-installed software, such as Apache, MySQL, PHP, Ruby on Rails, and Java. Software load balancing is available as an accelerator in addition to hardware load balancers.

A notable feature of Joyent’s virtual servers is automatic vertical scaling of CPU cores, which means a virtual server can make use of additional CPUs automatically up to the maximum number of cores available in the physical host.

In summary, the Joyent public cloud offers the following features: multiple geographic locations in the United States; Web-based user interface; access to virtual server via SSH and Web-based administration tool; 100% availability SLA; per month pricing; OS-level virtualization Solaris containers; Open-Solaris operating systems; automatic scaling (vertical).

GoGrid. GoGrid, like many other IaaS providers, allows its customers to utilize a range of pre-made Windows and Linux images, in a range of fixed instance sizes. GoGrid also offers “value-added” stacks on top for applications such as high-volume Web serving, e-Commerce, and database stores. It offers some notable features, such as a “hybrid hosting” facility, which combines traditional dedicated hosts with auto-scaling cloud server infrastructure. In this approach, users can take advantage of dedicated hosting (which may be required due to specific performance, security or legal compliance reasons) and combine it with on-demand cloud infrastructure as appropriate, taking the benefits of each style of computing.

As part of its core IaaS offerings, GoGrid also provides free hardware load balancing, auto-scaling capabilities, and persistent storage, features that typically add an additional cost for most other IaaS providers.

Rackspace Cloud Servers. Rackspace Cloud Servers is an IaaS solution that provides fixed size instances in the cloud. Cloud Servers offers a range of Linux-based pre-made images. A user can request different-sized images, where the size is measured by requested RAM, not CPU.

Like GoGrid, Cloud Servers also offers hybrid approach where dedicated and cloud server infrastructures can be combined to take the best aspects of both styles of hosting as required. Cloud Servers, as part of its default offering, enables fixed (static) IP addresses, persistent storage, and load balancing (via A-DNS) at no additional cost.

Source of Information : Wiley - Cloud Computing Principles and Paradigms 2011

Diagnostics in the cloud

2012-01-28T23:26:00.000+08:00

At some point you might need to debug your code, or you’ll want to judge how healthy your application is while it’s running in the cloud. We don’t know about you, but the more experienced we get with writing code, the more we know that our code is less than perfect. We’ve drastically reduced the amount of debugging we need to do by using test-driven development (TDD), but we still need to fire up the debugger once in a while.

Debugging locally with the SDK is easy, but once you move to the cloud you can’t debug at all; instead, you need to log the behavior of the system. For logging, you can use either the infrastructure that Azure provides, or you can use your own logging framework. Logging, like in traditional environments, is going to be your primary mechanism for collecting information about what’s happening with your application.

Using Azure Diagnostics to find what’s wrong
Logs are handy. They help you find where the problem is, and can act as the flight data recorder for your system. They come in handy when your system has completely burned down, fallen over, and sunk into the swamp. They also come in handy when the worst hasn’t happened, and you just want to know a little bit more about the behavior of the system as it’s running. You can use logs to analyze how your system is performing, and to understand better how it’s behaving. This information can be critical when you’re trying to determine when to scale the system, or how to improve the efficiency of your code.

The drawback with logging is that hindsight is 20/20. It’s obvious, after the crash, that you should’ve enabled logging or that you should’ve logged a particular segment of code. As you write your application, it’s important to consider instrumentation as an aspect of your design.

Logging is much more than just remote debugging, 1980s-style. It’s about gathering a broad set of data at runtime that you can use for a variety of purposes; debugging is one of those purposes.

Challenges with troubleshooting in the cloud
When you’re trying to diagnose a traditional on-premises system, you have easy access to the machine and the log sources on it. You can usually connect to the machine with a remote desktop and get your hands on it. You can parse through log files, both those created by Windows and those created by your application. You can monitor the health of the system by using Performance Monitor, and tap into any source of information on the server. During troubleshooting, it’s common to leverage several tools on the server itself to slice and dice the mountain of data to figure out what’s gone wrong.

You simply can’t do this in the cloud. You can’t log in to the server directly, and you have no way of running remote analysis tools. But the bigger challenge in the cloud is the dynamic nature of your infrastructure. On-premises, you have access to a static pool of servers. You know which server was doing what at all times. In the cloud, you don’t have this ability. Workloads can be moved around; servers can be created and destroyed at will. And you aren’t trying to diagnose the application on one server, but across a multitude of servers, collating and connecting information from all the different sources. The number of servers used in cloud applications can swamp most diagnostic analysis tools. The shear amount of data available can cause bottlenecks in your system.

For example, a typical web user, as they browse your website and decide to check out, can be bounced from instance to instance because of the load balancer. How do you truly find out the load on your system or the cause for the slow response while they were checking out of your site? You need access to all the data that’s available on terrestrial servers and you need the data collated for you.

You also need close control over the diagnostic data producers. You need an easy way to dial the level of information from debug to critical. While you’re testing your systems, you need all the data, and you need to know that the additional load it places on the system is acceptable. During production, you want to know only about the most critical issues, and you want to minimize the impact of these issues on system performance.

For all these reasons, the Windows Azure Diagnostics platform sits on top of what is already available in Windows. The diagnostics team at Microsoft has extended and plugged in to the existing platform, making it easy for you to learn, and easy to find the information you need.

Source of Information : Manning Azure in Action 2010

THE FIVE WINDOWS SERVER 2008 TERMINAL SERVICES ROLE SERVICES

2012-01-24T23:08:00.000+08:00

The TS role is split into five parts called role services. Each role service performs its own unique function and each is explained in this section.

Terminal Server
A server with the Terminal Server role service installed is referred to as a terminal server. It hosts the Remote Desktop sessions and the Windowsbased applications that are made available to your users.

TS Licensing
Each connection to a terminal server requires a TS client access license also known as a TS CAL. There are two types of TS CALs: TS Per Device CALs and TS Per User CALs. If Per Device licensing is chosen, you will need to purchase a CAL for each device in your enterprise that may be used to access your TS infrastructure. This can be a more economical choice if you have more users than computers in your enterprise. Per User licensing requires you to purchase a CAL for each user that may access your TS deployed applications or desktops. This is often the choice made by companies whose employees need to make a TS connection from a variety of different machines. It is highly recommended that you consult with a Microsoft licensing specialist when deciding which path is right for you. TS CALs are managed by a TS Licensing server, and you are required to have at least one in any TS infrastructure. If you implement a large TS environment with multiple terminal servers, it is recommended that you install TS Licensing on a separate server. However, if you are implementing a TS environment with a small footprint or just for testing you can install TS Licensing on a server running the Terminal Server role. For more detailed information on the installation and configuration of TS Licensing you can go to http://go.microsoft.com/fwlink/?linkid¼85873.

TS Session Broker
The TS Session Broker serves two purposes in a TS environment with a farm of terminal servers. The first is TS Session Broker Load Balancing. When this feature is enabled, the TS Session Broker monitors the number of TS sessions open to each terminal server and directs new session requests to the server with the fewest open sessions. This allows for an even distribution of sessions across all servers in a farm. The second function provided is the ability to ensure a TS user is automatically
reconnected to their active session, if one exists. TS Session Broker tracks information on all open sessions within the farm, recording which user sessions reside on which terminal server. This allows a user to pick up where they left off if their session is unexpectedly disconnected. More detailed information on the installation and configuration of TS Session Broker can be found at http://go.microsoft.com/fwlink/?linkid¼92670.

TS Gateway
By leveraging TS Gateway, a TS environment and computer with Remote Desktop enabled can be configured to be accessible by authorized users over the public Internet without the need for an additional secure method to access your internal network such as a Virtual Private Network (VPN) connection. This is done by establishing an RDP over HTTPS connection from an Internet connected computer over port 443 versus the standard RDP port 3389. Security settings for this access are configured via TS Gateway Manager and include the ability to define several parameters, such as authorized Active Directory user and computer groups, accessible network resources, device and disk redirection, and acceptable authentication methods like passwords or
smart cards. For TS Gateway installation information and a step-by-step installation guide, you can go to http://go.microsoft.com/fwlink/?linkid¼85872.

TS Web Access
TS Web Access makes available from a web browser the applications you publish with the traditional TS methods, such as RemoteApp programs and virtual desktops. You can choose to limit the access to the TS Web Access Web site to your local intranet or use it with TS Gateway as another way to enable your users to access TS applications from across the public Internet.

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

Presentation virtualization (Terminal Services)

2012-01-19T23:03:00.000+08:00

Presentation virtualization is a buzz phrase that refers to the features and functionality delivered by Windows Server 2008 version of Terminal Services (TS). With TS you can publish an entire Windows desktop just as in previous versions of TS. This enables your users to make a Remote Desktop connection to a terminal server accessing a fully functional desktop environment. In addition, by leveraging a subcomponent of TS called TS RemoteApp, you can publish individual applications that appear to be running locally on the desktop, but are actually running in your data center on a terminal server.

The value of the TS approach to application deployment is realized in multiple areas. In an enterprise with remote locations utilizing slow links back to a centralized data center, this technology can substantially reduce the bandwidth used across slow Wide Area Network (WAN) circuits. This is because only the keyboard and mouse input along with display information is transmitted keeping the data flow between the TS server and the data source exclusively over the data center Local Area Network (LAN).

TS can enable you to extend the useful life of client computers by moving the heavy processing off of the aging client equipment and onto your terminal servers. This allows you to implement newer more intensive applications without having to perform an expensive and time-consuming enterprisewide PC upgrade project. Along a similar line, performing an upgrade of a TS deployed application is accomplished from your centralized data center location. This can eliminate the need to visit all of the client computers in your enterprise to upgrade a locally installed program. Depending on the circumstances (numbers of computers and remote locations, etc.) this can save your company a considerable amount of money and you a considerable amount of time.

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

NEW FEATURES IN APP-V 4.5

2012-01-16T22:59:00.000+08:00

AutoLoad packages
One of the new features in Version 4.5 of App-V is the AutoLoad settings in the registry. These settings are created during the client installation and can be adjusted. By default, when a user logs on, the client attempts to load all previously used applications in cache. This ensures all features for are available locally on the computer. For mobile users, this option enables them to leave the network and still be able to use any application that has previously launched. However, this does not give them access to published applications that have not launched before. The AutoLoad options can be modified to download all applications published for a user and can also be triggered by a background publishing refresh.

Application streaming with Streaming Servers
Another new component in Version 4.5 is the Streaming Server. The Streaming Server does not provide the publishing refresh process. It relies on another resource to perform this operation. The publishing refresh process is achieved by implementing a Management Server to handle the publishing refresh and using the Application Source Root (ASR) setting on the client to point to the Streaming Server. You can also use the manifest.xml file created during sequencing to script the package publishing using SFTMIME. These options provide flexibility in remote office scenarios. Streaming Servers implement authorization via NTFS permissions.

Application streaming with File Servers
A file server can deliver packages in an App-V infrastructure, but like the Streaming Server, it cannot provide the publishing refresh process to the clients. As previously noted, this is accomplished by providing a Management Server for the publishing refresh process. This file server could be an actual server or a powerful desktop. File servers implement authorization by using NTFS permissions.

Application streaming with IIS
IIS can also be used for streaming. However, like the Streaming Server and the File server, it cannot provide the publishing refresh process to the clients. The client supports a publishing refresh over an HTTP/HTTPS connection. However, App-V currently has no Web-based publishing refresh service. So the IIS streaming option would require a Management Server to publish applications. IIS Servers implement authorization by using NTFS permissions.

Stand-alone mode with MSI
The App-V Sequencer supports creation of an MSI during the sequencing process. The stand-alone option does not have a formal publishing or streaming procedure. The MSI contains the ICO, OSD, and Manifest. xml files that are necessary for publishing the application on the machine and importing the SFT file into the App-V client cache. However, the package file (SFT) is not created as part of the MSI. It should be placed in the same directory as the MSI to successfully complete. You can place SFT files on a file server. In this scenario, the administrator uses the SFTPATH parameter to specify an alternate location of the SFT file. This removes the requirement that the SFT file to be in the same directory as the MSI. In Stand-alone mode the package will be published and the SFT file contents will be loaded into the client cache completely.

Streaming mode with MSI
Another option is to use MSI packages and choose to stream the SFT file from an alternate location. In this configuration the package is published, but the SFT file is streamed to the App-V client cache. The process of streaming the SFT file is done by default as part of the installation of the MSI, but could optionally be configured to happen when the user launches the application the first time. This mode enables the features of streaming, such as Active Upgrade. The following registry key value must be set on the client to enable Streaming Mode supporting MSI deployment:

HKLM\SOFTWARE\Microsoft\Softgrid\4.5\Client

» Configuration\AllowIndependentFileStreaming ¼ 1

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

CREATING AN APP-V PACKAGE

2012-01-14T22:51:00.000+08:00

Microsoft’s best practices for sequencing applications, walk you through the steps of creating an App-V package, and explain the various options for publishing that application.

Before sequencing, familiarize yourself with installation and use of the target application. Failure to fully understand the configuration and functionality of the application prior to sequencing may lead to an inefficiently sequenced package; one that may not work all. Specifically,

» What are all of the application components needed to complete the installation of the application?

» What updates such as adding new files to the package will need to be performed while sequencing?

» What postinstallation configuration steps need to take place while sequencing?

» How is the application commonly used by its target users?

When sequencing on Windows Vista or Windows 7, configure the User Account Control (UAC) as it will exist on the target desktops. Disable the UAC if it is disabled on your target client machines.

Always use the Comments field in the sequencer to include details about the package you may want to reference in the future. This allows the sequencer to maintain a log of your actions.

Always sequence to a unique, 8.3 directory name. This applies to both the Asset and Installation directories. (‘Q:\MYAPP’ and ‘Q:\MYAPP.001’ are correct, ‘Q:\My Application’ is incorrect.)

Sequence to a folder in the root of the drive, not to a subdirectory (‘Q:\MYAPP’ is correct; ‘Q:\’ is incorrect; ‘Q:\Temp_Junk\MYAPP’ is incorrect). If the suite has multiple parts, install each application in a subdirectory of the Asset Directory. For example, if a package contains a primary application with the Java Client, use Q:\AppSuite as the Asset Directory; sequence the application to Q:\AppSuite\APP; and sequence the Java Client to Q:\AppSuite\JavaClient.

Use globally unique paths and Package names across the set of application sequencings. For example, place multiple Microsoft Office sequencings in the same Asset Directory name. Use a standardized naming scheme that can be incremented, for example, Q:\OFFXP.v1 or Q:\OFFXP.001.

Launch, configure, and test the application during the installation phase. Often this requires performing several manual steps that are not part of the application installation process, such as configuring database connections, copying updated files, etc. Launch and use the application multiple times in order to ensure that all of the most common features are utilized and captured properly by the sequencer. For example, run the application to get past any registration or initial pop-up dialog boxes. Some applications perform different tasks on first launch, second launch, and sometimes subsequent launches. Multiple launches ensure relevant application code makes it into Feature Block 1 during the execution phase. Use the Application Wizard to launch each executable in a suite of applications; do not just browse to their location under All Programs. Doing so may result in the sequencer failing to grab the proper first launch data for the primary feature block.

Some applications have the option to Install on First Use for certain components. Do not sequence applications with this option selected.

Disable any Auto Update features. Some applications have the ability to check a Web site or a server for the latest application updates. Leaving this feature enabled will not break the application, but it may affect version integrity should the application ever be resequenced to apply updates.

There are applications that cannot or should not be sequenced, and there are limitations within App-V. The following list of applications that SHOULD NOT be sequenced is provided by Microsoft:

» Applications (when sequenced) that are over 4 GB in size. If the application is too large the sequencer will not save the application. It will attempt to compress the file.

» Applications that start services at boot time. App-V requires a logged in user initiate the launch of an application.

» Applications that require device drivers. App-V cannot virtualize drivers, but it may be possible to bypass this issue and install the driver locally on the target computer, outside of the App-V package.

» Applications required by several applications for information or access. For example, a program that launches another program. Normally you want to include both programs in the same suite. However, this is not always possible. This is especially true if one of the reasons you are deploying App-V is to avoid application conflicts. Remember that the virtual “bubble” can see the OS and what is installed on it but the OS can neither see the “bubble” nor interact with it.

» Applications that are a part of the operating system, such as Internet Explorer.

» Applications that use COMþ. COMþ is dynamic and initiates at runtime. The sequencer cannot capture this information.

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

INSTALLING THE APP-V SEQUENCER

2012-01-11T15:05:00.000+08:00

Before installing the Sequencer on a workstation or server, there are some items that you must be aware of, and may want to configure in advance. Microsoft’s support requirement since version 4.2 of App-V has been to sequence and publish on “like” operating systems. This means that creating a sequenced package on Windows XP and then publishing that package to Vista, and vice versa is not supported. You should plan to have a sequencer workstation or server for every operating system you plan to publish applications to. For example, to publish to a Server 2003 operating system, you must create the package on a Server 2003 operating system, including service pack and hot fix level. Although you may be able to sequence on one operating system and publish to another, the practice is not supported.

In addition to operating system, service pack, and hot fix level, you will also want to include any applications that are a part of your base image. For example, if Adobe Reader is a part of your base image, you should include it in the building of your sequencer workstation. This is especially important if you include the Microsoft Office suite on your base image. Some applications install differently if they see that Microsoft Office is
already installed.

If you plan to package applications that include ODBC DSN settings, you will want to create one on the sequencer workstation prior to sequencing a package. The registry key associated with the ODBC setting will become virtualized and prohibit the packaged application from seeing any ODBC DSN settings on the base client machine.

The following locations can be checked to determine ODBC information was captured:

» Search for odbc.ini: It will be located in the VFS\%CSIDL_WINDOWS% folder
» HKLM\Software\ODBC\ODBC.INI\ODBC Data Sources
» HKCU\%SFT_SID%\Software\ODBC\ODBC.INI

You will want to include a printer as part of the Sequencer base image as well. Printer configurations are handled like ODBC settings. So it is necessary to include a printer device in the sequencer PC image.

You will need to set up your sequencer machine with at least two primary partitions. The first partition, C:, should have the operating system installed; format it as NTFS. The second partition, Q:, is used as the destination path for the application installation. It should also be formatted as NTFS.

The sequencer uses %TMP%, %TEMP%, and its own scratch directory for temporary files. These locations should be large enough to accommodate the full installation size of the application being packaged. The sequencer uses the scratch directory to temporarily store the files generated during the sequencing process. The location of the scratch directory can be seen by launching the sequencer and browsing to Options | Tools and then clicking the Paths tab. You can improve performance by configuring the temp directories and the scratch directory to reside on different physical hard drives.

Before you begin to sequence an application, you will want to shutdown other programs that may be running. Ensure no scheduled tasks are running, or will begin running, during the sequencing process. Disable the following programs before starting a sequencing job:

» Windows Defender
» Antivirus Software
» Disk defragmentation software
» Windows Search
» Microsoft update
» Any open Windows Explorer session

All components for the App-V Sequencer are available through the Microsoft Volume Licensing Site (https://licensing.Microsoft.com). The link is called “Application Virtualization Hosting for Desktops 4.5” and can be found under the Windows section. Once downloaded, extract the files or burn the ISO to a CD.

1. Using the media you just downloaded in the previous step, browse to. . . | App-V | Installers | Sequencer and click Setup.exe.

2. The setup wizard prompts you to install the Microsoft Cþþ Redistributable Package, Microsoft MSXML, and Microsoft Application Error Reporting if they are not already installed. Click Install.

3. Once the prerequisites have been installed (or if they were already installed), you are taken to the Welcome page for the Application Virtualization Sequencer. On the Welcome page click Next.

4. Read and accept the license agreement, and then click Next. Doing so takes you to the Setup Page. Leave the installation path at its default setting and click Next.

5. Click Install to begin the installation of the App-V Sequencer.

6. When the installation completes, click Finish. The Sequencer will now start.

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

App-V SYSTEM REQUIREMENTS

2012-01-06T15:00:00.000+08:00

You will notice the system requirements for the App-V Sequencer and Client are very similar to a typical end-user workstation.

➤ App-V Sequencer Requirements
o Processor—IntelW PentiumW III, 850 MHz or faster. The sequencing process is a single-threaded process; it does not take advantage of dual processors.

o Memory—256 MB RAM or greater. A 500 MB page file is recommended.

o Hard drive—Two physical drives, 20-GB minimum each. (Install the operating system and local applications on one drive, and use the second drive as the target for your virtual applications.) It is recommended your disk drives should be at least three times as large as the largest application you will sequence. If you have only one hard drive, you must use at least two NTFS volumes to partition it.

o Operating system (this must be the same as the clients)—The Sequencer runs on the following operating systems:
- Windows XP Professional (SP2 or SP3)
- Windows Server 2003
- Windows Vista
- Windows Server 2008 with Terminal Services
- Windows 7

App-V Client requirements
Now we will discuss two App-V client requirements: App-V Desktop Client and App-V Terminal Services Client.

App-V Desktop Client
» Processor—See recommended system requirements for the operating system you are using.
» RAM—See recommended system requirements for the operating system you are using.
» Disk—30 MB for installation and 4096 MB for cache.
» Windows XP Professional (SP2 or SP3) 32-bit
» Windows Vista RTM/SP1 (Business, Enterprise, or Ultimate) 32-bit
» Windows 7

The following software prerequisites are installed automatically if the setup.exe method is used. For setup.msi install program, these must be installed first. Microsoft recommends using setup.exe.

» Microsoft Visual Cþþ 2005 SP1 Redistributable Package (_86)—For more information about installing Microsoft Visual Cþþ 2005 SP1 Redistributable Package (_86), see http://go.microsoft.com/fwlink/?LinkId¼119961.

» Microsoft Core XML Services (MSXML) 6.0 SP1 (_86)—For more information about installing Microsoft Core XML Services (MSXML) 6.0 SP1 (_86), see http://go.microsoft.com/fwlink/?LinkId¼63266.

» Microsoft Application Error Reporting—The install program for this
software is included in the Support\Watson folder in the self-extracting
archive file.

App-V Terminal Services Client
» Processor—See recommended system requirements for the operating system you are using
» RAM—See recommended system requirements for the operating system you are using (also depends on the number of users and applications)
» Disk—30 MB for installation and 2 GB for cache
» Windows Server 2003 (Standard, Enterprise, or Datacenter, SP1 or later) 32-bit
» Windows Server 2008 (Standard, Enterprise, Datacenter) 32-bit
» Windows 7

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

WHAT IS AN APP-V PACKAGE?

2012-01-03T14:48:00.000+08:00

An App-V package is the next generation of an application installation. Apart from some specialized scenarios, most applications prior to the introduction of App-V were simply “installed” on a user’s workstation and the state of the installation remains largely static unless the user or their network administrator choose to force the application to upgrade,
update, etc. An App-V package is much more dynamic in that it can be
custom designed to

» Reside completely on a user’s workstation
» Partially on a user’s workstation and partially on a server
» Completely on a server only allowing access to the application from the user’s workstation
» And many variances in-between.

This approach allows you to efficiently maintain an App-V package. For example, an App-V package can be designed to install completely on a user’s workstation and still regularly “check-in” to the App-V infrastructure to look for updates, and then apply those updates in the background without impacting the user’s experience of the application.

Isolating an application addresses application compatibilities that otherwise would make it impossible to run two applications on the same workstation. An example of this is two different applications, each requiring a different version of the Java runtime. Prior to App-V, installing both applications on the same desktop caused pain and frustration. App-V allows you to package an application together with its prerequisites, and then stream the collective package to a workstation without the need to actually “install” anything on the user’s workstation. You can do this for any or all applications, including two different versions of the same program.

Application Virtualization Sequencer
The Sequencer is a wizard-based tool; App-V administrators will come to
use and appreciate more than any other function in the App-V world. The
Sequencer is used to create App-V sequenced applications and produce an
application “package.” A package consists of several files, including

» A sequenced application (.sft) file
» Open Software Description (.osd) “link” files
» Icon (.ico) files
» A manifest xml file that can be used to distribute sequenced applications with electronic software delivery (ESD) systems
» A project (.sprj) file

The Sequencer can also be used to build Windows Installer files (.msi) for deployment to clients configured for stand-alone operation. The .sft, .osd, and .ico files are stored in a shared content folder on the Management Server and are used by the App-V client to access and run sequenced applications.

Application Virtualization Client
The App-V Client is required on endpoint devices receiving applications from the App-V environment. It allows for management of package streaming on the client device; such as how much local cache is to be used by the application. It also manages how often the application checks in for any changes, and any user-specific configuration settings.

Source of Information : Elsevier-Microsoft Virtualization Master Microsoft Server Desktop Application and Presentation

Cell Phone Technologies

2011-12-31T23:40:00.000+08:00

Cell phone technology seems an obvious approach to mobile computer communication, and indeed data services based on cellular standards are commercially available. One drawback is the cost to users, due in part to cellular’s use of licensed spectrum (which has historically been sold off to cellular phone operators for astronomical sums). The frequency bands that are used for cellular telephones (and now for cellular data) vary around the world. In Europe, e.g., the main bands for cellular phones are at 900 and 1800 MHz. In North America, 850-and 1900-MHz bands are used. This global variation in spectrum usage creates problems for users who want to travel from one part of the world to another, and has created a market for phones that can operate at multiple frequencies (e.g., a tri-band phone can operate at three of the four frequency bands mentioned above). That problem, however, pales in comparison to the proliferation of incompatible standards that have plagued the cellular communication business. Only recently have some signs of convergence on a small set of standards appeared. And finally, there is the problem that most cellular technology was designed for voice communication, and is only now starting to support moderately high-bandwidth data communication.

Like 802.11 and WiMAX, cellular technology relies on the use of base stations that are part of a wired network. The geographic area served by a base station’s antenna is called a cell. A base station could serve a single cell or use multiple directional antennas to serve multiple cells. Cells do not have crisp boundaries, and they overlap. Where they overlap, a mobile phone could potentially communicate with multiple base stations. This is somewhat similar to the 802.11 picture. At any time, however, the phone is in communication with, and under the control of, just one base station. As the phone begins to leave a cell, it moves into an area of overlap with one or more other cells. The current base station senses the weakening signal from the phone, and gives control of the phone to whichever base station is receiving the strongest signal from it. If the phone is involved in a call at the time, the call must be transferred to the new base station in what is called a handoff .

As we noted above, there is not one unique standard for cellular, but rather a collection of competing technologies that support data traffi c in different ways and deliver different speeds. These technologies are loosely categorized by “ generation. ” The first generation (1G) was analog, and thus of limited interest from a data communications perspective. Most of the cell phone technology currently deployed is considered second generation (2G) or “ 2.5G ” (not quite worthy of being called 3G, but more advanced than 2G). The 2G and later technologies are digital. The most widely deployed 2G technology is referred to as GSM — the Global System for Mobile Communications — which is used in more than 200 countries. North America, however, is a late adopter of GSM, which helped prolong the proliferation of competing standards.

Most 2G technologies use one of two approaches to sharing a limited amount of spectrum between simultaneous calls. One way is a combination of frequency-division multiplexing (FDM) and time-division multiplexing (TDM). The spectrum available is divided into disjoint frequency bands, and each band is subdivided into time slots. A given call is allocated every n th slot in one of the bands. The other approach is code division multiple access (CDMA). CDMA does not divide the channel in either time or frequency, but rather uses different chipping codes to distinguish the transmissions of different cell phone users.

The 2G and later cell phone technologies use compression algorithms tailored to human speech to compress voice data to about 8 Kbps without losing quality. Since 2G technologies focus on voice communication, they provide connections with just enough bandwidth for that compressed speech — not enough for a decent data link. One of the first cellular data standards to gain widespread adoption is the General Packet Radio Service (GPRS), which is part of the GSM set of standards and is often referred to as a 2.5G technology.

GSM networks make use of a multiplexing technique called time-division multiple access (TDMA). (Confusingly, there is also a particular cellular standard that is sometimes called TDMA, but is known formally as IS-136.) You can think of TDMA as being like TDM — traditionally used for telephone services — with the additional feature that the timeslots can be dynamically allocated to users or devices that need them (and deallocated from devices that no longer need them). The number of timeslots that are available for GPRS at a given frequency depends on how many cellular voice calls are currently in progress, since voice calls also consume timeslots. As a result, GPRS data rates tend to be lower in busy cells. In practice, users often get between 30 and 70 Kbps — coincidentally, just about the same as a user of a dial-up modem on a landline. Nevertheless, GPRS has proven quite useful and popular in some parts of the world as a way to communicate wirelessly when faster connection methods (such as 802.11) are not available. Other 2.5G data standards have also become available and some manage to be quite a bit higher in bandwidth than GPRS.

The concept of a third generation (3G) was established before there was any implementation of 3G technologies, with the aim of shaping a single international standard that would provide much higher data bandwidth. Unfortunately, at the time of writing, several mutually incompatible 3G standards are emerging. Thus, the possibility that cellular standards will continue to diverge seems quite realistic. Interestingly, all the 3G standards are based on variants of CDMA. For example, the Universal Mobile Telecommunications System (UMTS) is based on wideband CDMA (W-CDMA). UMTS appears poised to be the successor to GSM, and in fact is sometimes referred to as 3GSM (i.e., the third-generation version of GSM). UMTS is intended to support data transfer rates of up to 1.92 Mbps, although real network conditions will probably result in lower rates in practice. Nevertheless, it should represent a significant performance improvement over GPRS. And like GSM, it should have quite widespread (if not actually universal) adoption around the world.

There are a number of commercial UMTS networks in operation at the time of writing with many more announced or planned. And to make it quite clear that work in this field is far from complete, we note that 3.5G and 4G standards are also in the works.

Finally , it should be noted that there is a class of mobile phones that are not cellular phones but satellite phones, or satphones . Satphones use communication satellites as base stations, communicating on frequency bands that have been reserved internationally for satellite use. Consequently, service is available even where there are no cellular base stations. Satphones are rarely used where cellular is available, since service is typically much more expensive. Satphones are also larger and heavier than modern cell phones because of the need to transmit and receive over much longer distances, to reach satellites rather than cellphone towers. Satellite communication is more extensively used in television and radio broadcasting, taking advantage of the fact that the signal is broadcast, not point-to-point. High-bandwidth data communication via satellite are commercially available, but its relatively high price (for both equipment and service) limits its use to regions where no alternative is available.

Source of Information : Elsevier Wireless Networking Complete 2010

Wireless Networks - WiMAX (802.16)

2011-12-26T23:34:00.000+08:00

WiMAX , which stands for Worldwide Interoperability for Microwave Access, was designed by the WiMAX Forum and standardized as IEEE 802.16. It was originally conceived as a last-mile technology. In WiMAX’s case that “ mile ” is typically 1 – 6 miles, with a maximum of about 30 miles, leading to WiMAX being classifi ed as a metropolitan area network (MAN). In keeping with a last-mile role, WiMAX does not incorporate mobility at the time of this writing, although efforts to add mobility are nearing completion as IEEE 802.16e. Also in keeping with the last-mile niche, WiMAX’s client systems, called subscriber stations , are assumed to be not end-user computing devices, but rather systems that multiplex all the communication of the computing devices being used in a particular building. WiMAX provides up to 70 Mbps to a single subscriber station.

In order to adapt to different frequency bands and different conditions, WiMAX defi nes several physical layer protocols. The original WiMAX physical layer protocol is designed to use frequencies in the 10- to 66-GHz range. In this range waves travel in straight lines, so communication is limited to line-of-sight (LOS). A WiMAX base station uses multiple antennas pointed in different directions; the area covered by one antenna’s signal is a sector . To extend WiMAX to near-LOS and non-LOS situations, several physical layer protocols were added that use the frequencies below 11 GHz (in the 10- to 11-GHz range, WiMAX can use either the original physical layer or one of the newer ones). Since this range includes both licensed and license-exempt frequencies, each of these physical layer protocols defines a variant better adapted to the additional interference and the regulatory constraints of the license-exempt frequencies.

The physical layer protocols provide two ways to divide the bandwidth between upstream
(i.e., from subscribers to base station) and downstream traffic: time-division duplexing (TDD) and frequency-division duplexing (FDD). TDD is simply STDM of the two streams; they take turns using the same frequency, and the proportion of upstream to downstream time can be varied dynamically, adaptively , by the base station. FDD is simply FDM of the two streams: one frequency is used for upstream and another for downstream. In license-exempt bands, the protocols use only TDD.

Both channels, upstream and downstream, must be shared not just among the many subscriber stations in a given sector, but also among the many WiMAX connections that each subscriber can have with the base station. WiMAX — unlike 802.11 and Ethernet — is connection oriented. One reason for this is to be able to offer a variety of QoS guarantees regarding properties such as latency and jitter, with the aim of supporting high-quality telephony and high-volume multimedia in addition to bursty data traffic. This is conceptually similar to some of the wired last mile technologies (such as DSL) with which WiMAX is intended to compete.

Sharing of the upstream and downstream channels is based on dividing them into equal-sized time slots. A WiMAX frame generally takes up multiple slots, with different frames taking different numbers of slots. The downstream channel (from base to subscribers) is relatively easy to subdivide into connections since only the base station sends on that channel. The base station simply sends addressed frames, one after the other. Each subscriber station in the sector receives all the frames, but ignores those not addressed to one of its connections.

In the upstream direction, how a connection gets handled depends on its QoS parameters.
Some connections get slots at a fixed rate, some get polled to determine how many slots they need currently, and some must request slots whenever they need them. Connections in this last category must contend to place their requests in a limited number of upstream slots set aside for contention. They use an exponential back off algorithm to minimize the chance of a collision, even on the first attempt.

A European alternative to WiMAX is HIPERMAN, which stands for high-performance radio metropolitan area network and uses the 2- to 11-GHz range. South Korea’s WiBro (for wireless broadband) technology operates at 2.3 GHz, and is being brought into line with the emerging IEEE 802.16e standard for mobile WiMAX.

Source of Information : Elsevier Wireless Networking Complete 2010

Wireless Networks - Wi-Fi (802.11)

2011-12-23T23:06:00.000+08:00

This section takes a closer look at a specific technology centered around the emerging IEEE 802.11 standard, also known as Wi-Fi . Wi-Fi is technically a trademark, owned by a trade group called the Wi-Fi alliance, that certifies product compliance with 802.11. Like its Ethernet and token ring siblings, 802.11 is designed for use in a limited geographical area (homes, office buildings, campuses), and its primary challenge is to mediate access to a shared communication medium — in this case, signals propagating through space. 802.11 supports additional features (e.g., time-bounded services, power management, and security mechanisms), but we focus our discussion on its base functionality.

Physical Properties
802 .11 runs over six different physical layer protocols (so far). Five are based on spread spectrum radio and one on diffused infrared (and is of historical interest only at this point). The fastest runs at a maximum of 54 Mbps.

The original 802.11 standard defined two radio-based physical layer standards, one using frequency hopping (over 79 1-MHz-wide frequency bandwidths) and the other using direct sequence (with an 11-bit chipping sequence). Both provide up to 2 Mbps. Then physical layer standard 802.11b was added. Using a variant of direct sequence, 802.11b provides up to 11 Mbps. These three standards run in the license-exempt 2.4 GHz frequency band of the electromagnetic spectrum. Then came 802.11a, which delivers up to 54 Mbps using a variant of frequency-division multiplexing (FDM) called orthogonal frequency-division multiplexing (OFDM) . 802.11a runs in the license-exempt 5-GHz band. On one hand, this band is less used, so there is less interference. On the other hand, there is more absorption of the signal and it is limited to almost the line of sight. The most recent standard is 802.11g, which is backward compatible with 802.11b (and returns to the 2.4-GHz band). 802.11g uses OFDM and delivers up to 54 Mbps. It is common for commercial products to support all three of 802.11a, 802.11b, and 802.11g, which not only ensures compatibility with any device that supports any one of the standards, but also makes it possible for two such products to choose the highest bandwidth option for a particular environment.

Collision Avoidance
At first glance, it might seem that a wireless protocol would follow the same algorithm as the Ethernet — wait until the link becomes idle before transmitting and back off should a collision occur — and to a first approximation, this is what 802.11 does. The additional complication for wireless is that, while a node on an Ethernet receives every other node’s transmissions, a node on an 802.11 network may be too far from certain other nodes to receive their transmissions (and vice versa).

A related problem, called the exposed node problem, occurs under the circumstances, where each of the four nodes is able to send and receive signals that reach just the nodes to its immediate left and right. For example, B can exchange frames with A and C but it cannot reach D, while C can reach B and D but not A. Suppose B is sending signal to A. Node C is aware of this communication because it hears B’s transmission. It would be a mistake, however, for C to conclude that it cannot transmit to anyone just because it can hear B’s transmission. For example, suppose C wants to transmit to node D. This is not a problem since C’s transmission to D will not interfere with A’s ability to receive from B. (It would interfere with A sending to B, but B is transmitting in our example.) 802.11 addresses these two problems with an algorithm called multiple access with collision avoidance (MACA).

The idea is for the sender and receiver to exchange control frames with each other before the sender actually transmits any data. This exchange informs all nearby nodes that a transmission is about to begin. Specifically, the sender transmits a request-to-send (RTS) frame to the receiver; the RTS frame includes a field that indicates how long the sender wants to hold the medium (i.e., it specifies the length of the data frame to be transmitted). The receiver then replies with a clear-to-send (CTS) frame; this frame echoes this length field back to the sender. Any node that sees the CTS frame knows that it is close to the receiver, and therefore cannot transmit for the period of time it takes to send a frame of the specified length. Any node that sees the RTS frame but not the CTS frame is not close enough to the receiver to interfere with it, and so is free to transmit.

There are two more details to complete the picture. Firstly, the receiver sends an acknowledgment (ACK) to the sender after successfully receiving a frame. All nodes must wait for this ACK before trying to transmit. Secondly, should two or more nodes detect an idle link and try to transmit an RTS frame at the same time, their RTS frames will collide with each other. 802.11 does not support collision detection, but instead the senders realize the collision has happened when they do not receive the CTS frame after a period of time, in which case they each wait a random amount of time before trying again. The amount of time a given node delays is defined by the same exponential back off algorithm used on the Ethernet.

Source of Information : Elsevier Wireless Networking Complete 2010

Wireless Networks - Bluetooth (802.15.1)

2011-12-21T22:39:00.000+08:00

Bluetooth fills the niche of very short-range communication between mobile phones, PDAs, notebook computers, and other personal or peripheral devices. For example, Bluetooth can be used to connect a mobile phone to a headset or a notebook computer to a printer. Roughly speaking, Bluetooth is a more convenient alternative to connecting two devices with a wire. In such applications, it is not necessary to provide much range or bandwidth. This is fortunate for some of the target battery-powered devices, since it is important that they not consume much power.

Bluetooth operates in the license-exempt band at 2.45 GHz. It has a range of only about 10 m. For this reason, and because the communicating devices typically belong to one individual or group, Bluetooth is sometimes categorized as a personal area network (PAN). Version 2.0 provides speeds up to 2.1 Mbps. Power consumption is low.

Bluetooth is specified by an industry consortium called the Bluetooth Special Interest Group. It specifies an entire suite of protocols, going beyond the link layer to define application protocols, which it calls profiles, for a range of applications. For example, there is a profile for synchronizing a PDA with a personal computer. Another profile gives a mobile computer access to a wired LAN in the manner of 802.11, although this was not Bluetooth’s original goal. The IEEE 802.15.1 standard is based on Bluetooth but excludes the application protocols.

The basic Bluetooth network configuration, called a piconet , consists of a master device and up to seven slave devices, as shown in Figure 2.3 . Any communication is between the master and a slave; the slaves do not communicate directly with each other. Because slaves have a simpler role, their Bluetooth hardware and software can be simpler and cheaper.

Since Bluetooth operates in a license-exempt band, it is required to use a spread spectrum technique to deal with possible interference in the band. It uses frequency hopping with 79 channels (frequencies), using each for 625 μm at a time. This provides a natural time slot for Bluetooth to use for synchronous time-division multiplexing. A frame takes up 1, 3, or 5 consecutive time slots. Only the master can start to transmit in odd-numbered slots. A slave can start to transmit in an even-numbered slot, but only in response to a request from the master during the previous slot, thereby preventing any contention between the slave devices.

A slave device can be parked: set to an inactive, low-power state. A parked device cannot communicate on the piconet; it can only be reactivated by the master. A piconet can have up to 255 parked devices in addition to its active slave devices. ZigBee is a newer technology that competes with Bluetooth to some extent. Devised by the ZigBee alliance and standardized as IEEE 802.15.4, it is designed for situations where the bandwidth requirements are low and power consumption must be very low to give very long
battery life. It is also intended to be simpler and cheaper than Bluetooth, making it financially feasible to incorporate in cheaper devices such as a wall switch that wirelessly communicates with a ceiling-mounted fan.

Source of Information : Elsevier Wireless Networking Complete 2010

Introducing column-oriented database storage scheme

2011-12-14T00:45:00.000+08:00

Column-oriented databases are among the most popular types of non-relational databases.
Made famous by the venerable Google engineering efforts and popularized by the growth of social networking giants like Facebook, LinkedIn, and Twitter, they could very rightly be called the flag bearers of the NoSQL revolution. Although column databases have existed in many forms in academia for the past few years, they were introduced to the developer community with the publication of the following Google research papers:

» The Google File System — http://labs.google.com/papers/gfs.html (October 2003)

» MapReduce: Simplifi ed Data Processing on Large Clusters — http://labs.google.com/papers/mapreduce.html (December 2004)

» Bigtable: A Distributed Storage System for Structured Data — http://labs.google.com/papers/bigtable.html (November 2006)

These publications provided a view into the world of Google’s search engine success and shed light on the mechanics of large-scale and big data efforts like Google Earth, Google Analytics, and Google Maps. It was established beyond a doubt that a cluster of inexpensive hardware can be leveraged to hold huge amounts data, way more than a single machine can hold, and be processed effectively and efficiently within a reasonable timeframe. Three key themes emerged:

» Data needs to be stored in a networked filesystem that can expand to multiple machines. Files themselves can be very large and be stored in multiple nodes, each running on a separate machine.

» Data needs to be stored in a structure that provides more flexibility than the traditional normalized relational database structures. The storage scheme needs to allow for effective storage of huge amounts of sparse data sets. It needs to accommodate for changing schemas without the necessity of altering the underlying tables.

» Data needs to be processed in a way that computations on it can be performed in isolated subsets of the data and then combined to generate the desired output. This would imply computational efficiency if algorithms run on the same locations where the data resides. It would also avoid large amounts of data transfer across the network for carrying out the computations on the humungous data set.

Building on these themes and the wisdom that Google shared, a number of open-source implementations spun off, creating a few compelling column-oriented database products. The most famous of these products that mirrors all the pieces of the Google infrastructure is Apache Hadoop. Between 2004 and 2006, Doug Cutting, creator of Lucene and Nutch, the open-source search engine software, initiated Hadoop in an attempt to solve his own scaling problems while building Nutch. Afterwards, Hadoop was bolstered with the help of Yahoo! engineers, a number of open-source contributors, and its early users, into becoming a serious production-ready platform. At the same time, the NoSQL movement was gathering momentum and a number of alternatives to Hadoop, including those that improved on the original model, emerged. Many of these alternatives did not reinvent the wheel as far as the networked fi lesystem or the processing methodology was concerned, but instead added features to the column data store. In the following section, I focus exclusively on the underpinning of these column-oriented databases.

Source of Information : NoSQL

GRAPH DATABASES

2011-12-09T00:31:00.000+08:00

So far I have listed most of the mainstream open-source NoSQL products. A few other products like Graph databases and XML data stores could also qualify as NoSQL databases. However, I list the two Graph databases that may be of interest and something you may want to explore beyond this book: Neo4j and FlockDB: Neo4J is an ACID-compliant graph database. It facilitates rapid traversal of graphs.
Neo4j
» Offi cial Online Resources — http://neo4j.org.
» History — Created at Neo Technologies in 2003. (Yes, this database has been around before the term NoSQL was known popularly.)
» Technologies and Language — Implemented in Java.
» Access Methods — A command-line access to the store is provided. REST interface also available. Client libraries for Java, Python, Ruby, Clojure, Scala, and PHP exist.
» Query Language — Supports SPARQL protocol and RDF Query Language.
» Open-Source License — AGPL. Who Uses It — Box.net.

FlockDB
» Offi cial Online Resources — https://github.com/twitter/flockdb
» History — Created at Twitter and open sourced in 2010. Designed to store the adjacency lists for followers on Twitter.
» Technologies and Language — Implemented in Scala.
» Access Methods — A Thrift and Ruby client.
» Open-Source License — Apache License version 2.
» Who Uses It — Twitter.

A number of NoSQL products have been covered so far. Hopefully, it has warmed you up to learn
more about these products and to get ready to understand how you can leverage and use them
effectively in your stack.

Source of Information : NoSQL

DISK STORAGE AND DATA READ AND WRITE SPEED

2011-12-06T22:52:00.000+08:00

While the data size is growing and so are the storage capacities, the disk access speeds to write data to disk and read data from it is not keeping pace. Typical above-average current-generation 1 TB disks claim to access data at the rate of 300 Mbps, rotating at the speed of 7200 RPM. At these peak speeds, it takes about an hour (at best 55 minutes) to access 1 TB of data. With increased size, the time taken only increases. Besides, the claim of 300 Mbps at 7200 RPM speed is itself misleading. Traditional rotational media involves circular storage disks to optimize surface area. In a circle, 7200 RPM implies different amounts of data access depending on the circumference of the concentric circle being accessed. As the disk is filled, the circumference becomes smaller, leading to less area of the media sector being covered in each rotation. This means a peak speed of 300 Mbps degrades substantially by the time the disk is over 65 percent full. Solid-state drives (SSDs) are an alternative to rotational media. An SSD uses microchips, in contrast to electromechanical spinning disks. It retains data in volatile random-access memory. SSDs promise faster speeds and improved “input/output operations per second (IOPS)” performance as compared to rotational media. By late 2009 and early 2010, companies like Micron announced SSDs that could provide access speeds of over a Gbps (www.dailytech.com/UPDATED+Micron+Announces+Worlds+First+

Native+6Gbps+SATA+Solid+State+Drive/article17007.htm). However, SSDs are fraught with bugs and issues as things stand and come at a much higher cost than their rotational media counterparts. Given that the disk access speeds cap the rate at which you can read and write data, it only make sense to spread the data out across multiple storage units rather than store them in a single large store.

Source of Information : NoSQL

NoSQL Databases - ZooKeeper

2011-12-03T00:00:00.000+08:00

When you’re running a service distributed across a large cluster of machines, even tasks like reading configuration information, which are simple on single-machine systems, can be hard to implement reliably. The ZooKeeper framework was originally built at Yahoo! to make it easy for the company’s applications to access configuration information in a robust and easy-to-understand way, but it has since grown to offer a lot of features that help coordinate work across distributed clusters. One way to think of it is as a very specialized key/value store, with an interface that looks a lot like a filesystem and supports operations like watching callbacks, write consensus, and transaction IDs that are often needed for coordinating distributed algorithms.

This has allowed it to act as a foundation layer for services like LinkedIn’s Norbert, a flexible framework for managing clusters of machines. ZooKeeper itself is built to run in a distributed way across a number of machines, and it’s designed to offer very fast reads, at the expense of writes that get slower the more servers are used to host the service.

Source of Information : Big data Glossary

NoSQL Databases - Riak

2011-12-01T00:00:00.000+08:00

Like Voldemort, Riak was inspired by Amazon’s Dynamo database, and it offers a key/ value interface and is designed to run on large distributed clusters. It also uses consistent hashing and a gossip protocol to avoid the need for the kind of centralized index server that BigTable requires, along with versioning to handle update conflicts. Querying is handled using MapReduce functions written in either Erlang or JavaScript. It’s open source under an Apache license, but there’s also a closed source commercial version with some special features designed for enterprise customers.

Source of Information : Big data Glossary

NoSQL Databases - Voldemort

2011-11-29T23:59:00.000+08:00

An open source clone of Amazon’s Dynamo database created by LinkedIn, Voldemort has a classic three-operation key/value interface, but with a sophisticated backend architecture to handle running on large distributed clusters. It uses consistent hashing to allow fast lookups of the storage locations for particular keys, and it has versioning control to handle inconsistent values. A read operation may actually return multiple values for a given key if they were written by different clients at nearly the same time. This then puts the burden on the application to take some sensible recovery actions when it gets multiple values, based on its knowledge of the meaning of the data being written. The example that Amazon uses is a shopping cart, where the set of items could be unioned together, losing any deliberate deletions but retaining any added items, which obviously makes sense—from a revenue perspective, at least!

Source of Information : Big data Glossary

NoSQL Databases - Hypertable

2011-11-27T23:58:00.000+08:00

Hypertable is another open source clone of BigTable. It’s written in C++, rather than Java like HBase, and has focused its energies on high performance. Otherwise, its interface follows in BigTable’s footsteps, with the same column family and timestamping concepts.

Source of Information : Big data Glossary

NoSQL Databases - HBase

2011-11-25T23:55:00.000+08:00

HBase was designed as an open source clone of Google’s BigTable, so unsurprisingly it has a very similar interface, and it relies on a clone of the Google File System called HDFS. It supports the same data structure of tables, row keys, column families, column names, timestamps, and cell values, though it is recommended that each table have no more than two or three families for performance reasons.

HBase is well integrated with the main Hadoop project, so it’s easy to write and read to the database from a MapReduce job running on the system. One thing to watch out for is that the latency on individual reads and writes can be comparatively slow, since it’s a distributed system and the operations will involve some network traffic. HBase is at its best when it’s accessed in a distributed fashion by many clients. If you’re doing serialized reads and writes you may need to think about a caching strategy.

Source of Information : Big data Glossary

NoSQL Databases - BigTable

2011-11-23T23:53:00.000+08:00

BigTable is only available to developers outside Google as the foundation of the App Engine datastore. Despite that, as one of the pioneering alternative databases, it’s worth looking at.

It has a more complex structure and interface than many NoSQL datastores, with a hierarchy and multidimensional access. The first level, much like traditional relational databases, is a table holding data. Each table is split into multiple rows, with each row addressed with a unique key string. The values inside the row are arranged into cells, with each cell identified by a column family identifier, a column name, and a timestamp, each of which I’ll explain below.

The row keys are stored in ascending order within file chunks called shards. This ensures that operations accessing continuous ranges of keys are efficient, though it does mean you have to think about the likely order you’ll be reading your keys in. In one example, Google reversed the domain names of URLs they were using as keys so that all links from similar domains were nearby; for example, com.google.maps/index.html was near com.google.www/index.html.

You can think of a column family as something like a type or a class in a programming language. Each represents a set of data values that all have some common properties; for example, one might hold the HTML content of web pages, while another might be designed to contain a language identifier string. There’s only expected to be a small number of these families per table, and they should be altered infrequently, so in practice they’re often chosen when the table is created. They can have properties, constraints, and behaviors associated with them.

Column names are confusingly not much like column names in a relational database. They are defined dynamically, rather than specified ahead of time, and they often hold actual data themselves. If a column family represented inbound links to a page, the column name might be the URL of the page that the link is from, with the cell contents holding the link’s text. The timestamp allows a given cell to have multiple versions over time, as well as making it possible to expire or garbage collect old data.

A given piece of data can be uniquely addressed by looking in a table for the full identifier that conceptually looks like row key, then column family, then column name, and finally timestamp. You can easily read all the values for a given row key in a particular column family, so you could actually think of the column family as being the closest comparison to a column in a relational database.

As you might expect from Google, BigTable is designed to handle very large data loads by running on big clusters of commodity hardware. It has per-row transaction guarantees, but it doesn’t offer any way to atomically alter larger numbers of rows. It uses the Google File System as its underlying storage, which keeps redundant copies of all the persistent files so that failures can be recovered from.

Source of Information : Big data Glossary

NoSQL Databases - Redis

2011-11-21T23:50:00.000+08:00

Two features make Redis stand out: it keeps the entire database in RAM, and its values can be complex data structures. Though the entire dataset is kept in memory, it’s also backed up on disk periodically, so you can use it as a persistent database. This approach does offer fast and predictable performance, but speed falls off a cliff if the size of your data expands beyond available memory and the operating system starts paging virtual memory to handle accesses. This won’t be a problem if you have small or predictably sized storage needs, but it does require a bit of forward planning as you’re developing applications. You can deal with larger data sets by clustering multiple machines together, but the sharding is currently handled at the client level. There is an experimental branch of the code under active development that supports clustering at the server level.

The support for complex data structures is impressive, with a large number of list and set operations handled quickly on the server side. It makes it easy to do things like appending to the end of a value that’s a list, and then trim the list so that it only holds the most recent 100 items. These capabilities do make it easier to limit the growth of your data than it would be in most systems, as well as making life easier for application developers.

Source of Information : Big data Glossary

NoSQL Databases - Cassandra

2011-11-19T23:33:00.000+08:00

Originally an internal Facebook project, Cassandra was open sourced a few years ago and has become the standard distributed database for situations where it’s worth investing the time to learn a complex system in return for a lot of power and flexibility. Traditionally, it was a long struggle just to set up a working cluster, but as the project matures, that has become a lot easier. It’s a distributed key/value system, with highly structured values that are held in a hierarchy similar to the classic database/table levels, with the equivalents being keyspaces and column families. It’s very close to the data model used by Google’s BigTable. By default, the data is sharded and balanced automatically using consistent hashing on key ranges, though other schemes can be configured. The data structures are optimized for consistent write performance, at the cost of occasionally slow read operations. One very useful feature is the ability to specify how many nodes must agree before a read or write operation completes. Setting the consistency level allows you to tune the CAP tradeoffs for your particular application, to prioritize speed over consistency or vice versa.

The lowest-level interface to Cassandra is through Thrift, but there are friendlier clients available for most major languages. The recommended option for running queries is through Hadoop. You can install Hadoop directly on the same cluster to ensure locality of access, and there’s also a distribution of Hadoop integrated with Cassandra available from DataStax.

There is a command-line interface that lets you perform basic administration tasks, but it’s quite bare bones. It is recommended that you choose initial tokens when you first set up your cluster, but otherwise the decentralized architecture is fairly low-maintenance, barring major problems.

Source of Information : Big data Glossary

NoSQL Databases - CouchDB

2011-11-17T23:31:00.000+08:00

CouchDB is similar in many ways to MongoDB, as a document-oriented database with a JavaScript interface, but it differs in how it supports querying, scaling, and versioning. It uses a multiversion concurrency control approach, which helps with problems that require access to the state of data at various times, but it does involve more work on the client side to handle clashes on writes, and periodic garbage collection cycles have to be run to remove old data. It doesn’t have a good built-in method for horizontal scalability, but there are various external solutions like BigCouch, Lounge, and Pillow to handle splitting data and processing across a cluster of machines. You query the data by writing JavaScript MapReduce functions called views, an approach that makes it easy for the system to do the processing in a distributed way. Views offer a lot of power and flexibility, but they can be a bit overwhelming for simple queries.

Source of Information : Big data Glossary

NoSQL Databases - MongoDB

2011-11-15T23:29:00.000+08:00

Mongo, whose name comes from "humongous”, is a database aimed at developers with fairly large data sets, but who want something that’s low maintenance and easy to work with. It’s a document-oriented system, with records that look similar to JSON objects with the ability to store and query on nested attributes. From my own experience, a big advantage is the proactive support from the developers employed by 10gen, the commercial company that originated and supports the open source project. I’ve always had quick and helpful responses both on the IRC channel and mailing list, something that’s crucial when you’re dealing with comparatively young technologies like these. It supports automatic sharding and MapReduce operations. Queries are written in JavaScript, with an interactive shell available, and bindings for all of the other popular languages.

Source of Information : Big data Glossary

NoSQL Databases

2011-11-13T23:22:00.001+08:00

A few years ago, web programmers started to use the memcached system to temporarily store data in RAM, so frequently used values could be retrieved very quickly, rather than relying on a slower path accessing the full database from disk. This coding pattern required all of the data accesses to be written using only key/value primitives, initially in addition to the traditional SQL queries on the main database. As developers got more comfortable with the approach, they started to experiment with databases that used a key/value interface for the persistent storage as well as the cache, since they already had to express most of their queries in that form anyway. This is a rare example of the removal of an abstraction layer, since the key/value interface is less expressive and lower-level than a query language like SQL. These systems do require more work from an application developer, but they also offer a lot more flexibility and control over the work the database is performing. The cut-down interface also makes it easier for database developers to create new and experimental systems to try out new solutions to tough requirements like very large-scale, widely distributed data sets or high throughput applications.

This widespread demand for solutions, and the comparative ease of developing new systems, has led to a flowering of new databases. The main thing they have in common is that none of them support the traditional SQL interface, which has led to the movement being dubbed NoSQL. It’s a bit misleading, though, since almost every production environment that they’re used in also has an SQL-based database for anything that requires flexible queries and reliable transactions, and as the products mature, it’s likely that some of them will start supporting the language as an option. If “NoSQL” seems too combative, think of it as “NotOnlySQL.” These are all tools designed to trade the reliability and ease-of-use of traditional databases for the flexibility and performance required by new problems developers are encountering.

With so many different systems appearing, such a variety of design tradeoffs, and such a short track record for most, this list is inevitably incomplete and somewhat subjective. I’ll be providing a summary of my own experiences with and impressions of each database, but I encourage you to check out their official web pages to get the most up-todate and complete view.

Source of Information : Big data Glossary

2010 Power Supplies You Care The Most About

2010-12-25T00:59:00.000+08:00

PSU vendors focused more on efficiency in 2010, and if a power supply offers an energy efficiency of greater than 80%, you can bet that it’ll be listed prominently on the box. Other popular additions include thermally regulated fans, sleeved cables, and quiet fan bearings. Most newer power supplies now include split PCI-E connectors to support a variety of graphics cards.

Winner: Enermax EMG800EWT MODU87+ 800W
$249.99; www.enermax.com
The Enermax EMG800EWT MODU87+ was one of our favorites in the June issue because of its Dynamic Hybrid Transformer topology, which improves the power supply’s ability to deliver consistent output with dynamic loads. The keys to the Dynamic Hybrid Transformer include a resonant transformer array that combines a resonant choke, the main transformer, a driver transformer, and a standby transformer; dynamic voltage transforming to provide power saving when idle; and dynamic frequency transforming for energy efficiency under load.

Overall, Enermax indicates the EMG800EWT MODU87+ 800W can deliver at least 87% efficiency at 20% and 100% load. Enermax also installs a 13.9cm Twister-bearing fan to reduce noise and improve the lifespan (100,000 hours MTBF) of the power supply. It offers ATX12V v2.3 support, so you can power the latest Intel and AMD processors, and the EMG800EWT MODU87+ 800W is also CrossFireXand SLI-ready. The 24-pin ATX, +12V auxiliary, and two 6+2 pin PCI-E connectors are built into the power supply; the rest of the power cables are modular. Enermax includes four 6+2 PCI-E plugs, 12 SATA connectors, and eight 4-pin Molex plugs.

We also like that Enermax includes its HeatGuard, SafeGuard, and CordGuard technology to protect the power supply’s circuitry and prolong use. For instance, the HeatGuard technology keeps the EMG800EWT MODU87+ running for 30 to 60 seconds after shutdown to remove the heat remaining in the power supply. Because of the unit’s 80 Plus Gold certification, it’s ideal for enthusiasts with a high-performance processor and one high-end or two midrange graphics cards.

First Runner-Up: Corsair Professional Series Gold AX1200
$277.99; www.corsair.com
We checked out the Corsair Professional Series Gold AX1200 in the August issue (see page 25) and found that it was ideal for power users. Some of the features of the AX1200 include a 100A (1,204.8W) single +12V rail, a fully modular cable system, and a lownoise design based around a thermallycontrolled 140mm fan. For power efficiency, the AX1200 offers individual DC-DC regulation for the +3.3V, +5V, and +12V rails. On the secondary side of the AX1200’s circuitry, Corsair employs low-loss MOSFETs in the synchronous rectification circuitry and in a four-layer modular connector board. Overall, the Professional Series Gold AX1200 meets the 80 Plus Gold efficiency standard.

Another benefit of the Professional Series Gold AX1200 is Corair’s Zero Voltage Switching and Zero Current Switching technology, which minimizes switching losses to improve efficiency and reduce waste heat. The 1,200 watts of power means that this Corsair power supply can handle pretty much any system you throw at it.

Second Runner-Up: PC Power & Cooling Silencer Mk II 750W
$159.99; www.pcpower.com
PC Power & Cooling rates the Silencer Mk II 750W as 88% efficient and indicates that the +3.3V, +5V, and +12V DC outputs run within 2% of regulation. We checked out the unit in the September issue and found that Silencer lived up to its name, because it was nearly noiseless during the testing process. To accomplish the quiet design, PC Power & Cooling installed a 135mm, ball-bearing, thermallycontrolled fan. The Silencer MkII 750 offers four PCI-E (two 6-pin, two 6+2 pin) connectors, eight SATA connectors, and support for both ATX12V and EPS12V motherboards. PC Power & Cooling offers a seven-year warranty on the Silencer MkII 750W.

2010 Processors You Care The Most About

Source of Information : Computer Power User (CPU) January 2011

2010 Memory You Care The Most About

2010-12-25T00:55:00.000+08:00

Other than the typical jumps in frequency speeds, RAM didn’t change too much in 2010. Intel’s X58 chipset is still the only one that works with triplechannel memory, while every other Intel and AMD chipset features a dualchannel configuration. The increase in RAM frequencies has led to greater heat, so there’s a greater need for cooling, including tall finned heat spreaders and fans for many memory modules faster than 1,800MHz.

Winner: 8GB Patriot Viper Xtreme Series DDR3-2000MHz (PX538G2000ELK)
$249.99; www.patriotmemory.com
Patriot’s Viper Xtreme series features an extruded aluminum shield that’s built around 6 grams of copper to efficiently cool the modules. Stock timings are 9-10- 9-27 at 1.65V. Patriot indicates that the 8GB DDR3-2000 kit has been optimized for performance on P55 chipsets. The modules are Intel XMP-ready, so you can easily overclock the memory using recommended settings and voltages.

We also like that this kit is comparatively affordable for an enthusiastlevel 8GB set that consists of two 4GB modules. And because the 8GB only takes up space in two slots, you have space to add more memory in the future. In CPU’s test of the 6GB triple-channel version, we experienced above average results in 3DMark Vantage, MainConcept, and WinRAR benchmark tests. The Viper Xtreme Series timings also give you flexibility when overclocking.

First Runner-Up: 12GB Corsair Dominator GT DDR3-2000 (CMT12GX3M3A2000C9)
$403.99; www.corsair.com
This 12GB kit consists of three 4GB modules and was one of the most popular choices for memory in our Dream PC issue. The Corsair Dominator GT triple-channel DDR3 memory runs at 2000MHz and includes Corsair’s Airflow fan to cool the modules, so you won’t need to invest in any third-party memory cooling. The red and black modules feature Corsair’s DHX (Dual-path Heat Xchange) design with tall finned heat spreaders to cool the fast memory.

The 12GB Corsair Dominator GT DDR3-2000 kit features timings of 9-10-9-27, and you can use one of the Intel XMP settings to overclock the memory or configure your own settings. We also like that the Corsair Dominator GT module’s fins are removable, so you can add extended fins, or connect a liquidcooler such as Corsair’s Hydro Series H30 memory cooler, to customize the modules to meet your overclocking needs. Corsair offers a limited lifetime warranty on the 12GB Corsair Dominator GT DDR3-2000 kit.

Second Runner-Up: 6GB Kingston HyperX T1 DDR3-1866 (KHX1866C9D3T1K3/6GX)
$142.99; www.kingston.com
The HyperX T1 series is the top of the line for Kingston, and this 6GB kit includes three 2GB DDR3 modules that can run at up to 1,866MHz. The affordable kit features impressive latency timings of 9-9-9-27, and you can program a CAS latency of 5, 6, 7, 8, 9, or 10. The extra-tall HyperX T1 heat spreaders (the modules measure 2.4 inches high) give Kingston the ability to push memory frequencies and timings. Each module of the 6GB HyperX T1 DDR3-1866 kit features a PCB made of 16 128MB 8-bit chips. The kit is Intel XMP-ready and comes with a limited lifetime warranty from Kingston.

2010 Storage Devices You Care The Most About

Source of Information : Computer Power User (CPU) January 2011

IE9 and HTML5: Deep Romance or Strange Bedfellows?

2010-09-11T01:50:00.000+08:00

Microsoft knows HTML5 is coming, and Internet Explorer 9 (IE9) needs to implement it or face irrelevance. With each successive platform preview release of IE9, Redmond has opened its arms wider to the technology. With the major revision to the Web’s markup language expected in HTML5, Microsoft seems to be staking out a large comfort zone. Will there be a no-go zone as well?

HTML5 includes a number of new capabilities and many of them pose an existential threat to Microsoft and desktop software in general. With Scalable Vector Graphics (SVG) and the new <canvas> tag, developers can render graphics and animation in the browser from JavaScript that IE8 can only display using Flash or Silverlight. With the new <audio> and <video> tags, media can be similarly embedded and played without the use of rich Internet application (RIA) plug-ins. And with the Web Open Font Format (WOFF), refined typography can be rendered in a Web page as true text, rather than as images. Taken together, these features allow HTML5 to compete vigorously with the media and presentation capabilities of Silverlight (and Flash).

Of these technologies, IE9 Platform Preview (PP) 2 implemented only SVG. While Microsoft said <audio> and <video> tag support was coming, many were unsure about <canvas> and WOFF. But PP3, released in late June, implemented all these features and moved Internet Explorer’s HTML5 fl irtation to serious courtship. Taking the relationship to the next level will be much more challenging.

There’s an App for That?
The Web has, for much of its history, functioned in two capacities. At first, it handled the sharing of documents, mostly among academics. Later, HTML was extended (some would say hacked) to accommodate simple, form-based applications as well. But Web applications haven’t provided for offline operation, nor offered any amenity for local database requirements. They have not been particularly well-suited to intensive data entry, either: things like required fields, input masks and pick lists have required client script, sometimes in great quantity. Given how crucial these capabilities are to line-of-business applications, the Web has not been an acceptable substitute to desktop and RIA development in the enterprise.

Components of the HTML5 draft specifi cation address these shortcomings too. Numerous enhancements to the <form> and <input> tags largely address the data entry issues, allowing declarative markup to be used in place of imperative script to get the UI and data validation working. Offl ine operation is made possible through the <html> tag’s manifest attribute and the cache manifest fi le. Local SQL database access is provided through JavaScript methods like openDatabase and executeSql. Many of these capabilities are implemented in the current versions of Chrome, Safari and Opera; some are implemented in Firefox as well, but none of these features is implemented in IE8, or even IE9 PP3. Will any of them make it into the fi nal IE9 product?

Microsoft, Choose Your Poison
If Microsoft doesn’t implement at least some of these capabilities, it risks further erosion of the IE market share. If it does implement them, Microsoft may risk something bigger: eventual erosion of Windows supremacy. It’s one thing if the consumer world moves to HTML for rich media, print content and games, but if the enterprise world moves to HTML5 as the application platform of choice, that could make the client OS a commodity.

On the consumer side, this also threatens Apple, but on the iPhone, iPod Touch and iPad, apps and the App Store are, culturally, the outlets for the premium experience. Apple’s comfortable with HTML5 because the Web is a second-class citizen on its hottest, newest platform. Could Microsoft pull a rabbit out of its hat with Windows Phone 7, and leverage it as Apple has leveraged iOS? Maybe. But the Microsoft culture, and its financial security, is oriented around Windows and Office, and HTML5 introduces enormous risk to that franchise.

IE9 needs to walk the line between making Windows the best platform in which to experience the modern Web, while at the same time thwarting the allure of that Web as the dominant host of enterprise applications. IE9 and HTML5 will continue this Tango until the browser ships. Tango is hard; Microsoft must take lessons and practice obsessively. The dance will shed much light on Microsoft’s market position for the next decade. Meanwhile, the Microsoft ecosystem needs to watch this performance very carefully. It will shed light on the ecosystem’s position too.

Source of Information : Visual Studio Magazine August 2010

Visual Studio 2010 Upgrade Tips

2010-09-10T01:22:00.000+08:00

Now for the caveats: If you move existing projects to Visual Studio 2010 from Visual Studio 2008 or 2005, your platform target is not updated. Visual Studio 2010 supports development targeting older framework libraries to aid in application deployment, but the project itself is altered to become a Visual Studio 2010 project and you won’t be able to open it in Visual Studio 2008. On the surface the changes are just version number changes in the project and solution files. Beneath the surface, there’s no guarantee that the structure of supporting files remains unchanged, so consider the move to Visual Studio 2010 a permanent one for your project, and keep backups in case you have a reason to revert. Changes to the workflow of data projects managed from Visual Studio (such as how you load scripts) are significant and may be confusing if you manage databases from Visual Studio.

Visual Studio 2010 is a full rewrite. While it’s effectively a 1.0 product, overall performance and stability are adequate. But you’re much more likely to experience quirky behavior (such as the Clipboard ring sometimes not working as expected) and occasional crashes than in Visual Studio 2008.

Pick up two or three tips a week from rereading this article, tip of the day sites, by having tips of the month at your local user group, or by exploring the menus and commands in the keyboard-mapping dialog. Consider buying Sara Ford’s “Microsoft Visual Studio Tips” (Microsoft Press, 2008). Ford’s book covers Visual Studio 2008, but almost all the tips also apply to Visual Studio 2010—and Ford’s donating her author proceeds to the Save Waveland Scholarship Fund, for Hurricane Katrina survivors in Waveland, Miss. Wherever you get your tips, the ones that make your life easier will stick and you’ll forget the ones that don’t. Visual Studio is a tremendously powerful tool that you can’t learn all at one time.

Source of Information : Visual Studio Magazine August 2010

Visual Studio 2010 Other Enhancements

2010-09-09T01:20:00.000+08:00

Visual Studio 2010 also has many miscellaneous improvements and support for libraries. The WPF designer is improved, and there’s a visual editor for the new Windows Workflow. XSLT gets a profiler and XSD gets a new designer. WPF and Silverlight get drag-and-drop data binding. ASP.NET gets many new features to support the vast improvements in development brought by jQuery and Model-View-Controller (MVC). The T4 code generator becomes a first-class citizen and a new style of T4 execution called preprocessed templates lets you generate code from apps outside Visual Studio, either with a standalone generator or your runtime application. Visual Studio 2010 embraces SharePoint development.

Windows Azure Tools for Visual Studio 2010 support cloud development. There’s better support for other languages, including F# in the box, and snippet support for HTML and JavaScript. Whew! There are an amazing number of improvements, and I’m skipping the plethora of features resulting from the efforts in architecture, testing, database management and other areas that are reserved for the Ultimate version.

Source of Information : Visual Studio Magazine August 2010

Visual Studio 2010 Improved IntelliSense

2010-09-08T01:18:00.000+08:00

IntelliSense received improvements in Visual Studio 2010. Visual Studio evaluates what you type against the Pascal interpretation of appropriate symbols, similar to the Pascal interpretation in the Navigate To dialog, narrowing IntelliSense options. This allows you to find things quickly where you remember only part of the symbol, generally the relevant portion, ignoring any preceding words like “Is” or “Allow.” The abbreviations let you quickly enter the symbols you frequently use. IntelliSense is now filtered for the current target platform—Microsoft .NET Framework 4 features won’t appear in IntelliSense of a project targeting Microsoft .NET Framework 3.5.

Previous versions of IntelliSense were awkward in a test-driven development (TDD) environment where the symbols do not yet exist. IntelliSense could be quite pushy, requiring frequent presses on the Esc key. Visual Studio 2010 offers a second mode for IntelliSense mode called suggestion mode. This mode assumes you may or may not be entering an existing symbol. The top of the suggestion mode IntelliSense box displays what will be entered if you close IntelliSense. You can use arrow keys or the mouse to select an existing item, or enter your text as written without IntelliSense interference:

Visual Studio 2010 also provides TDD support through the Generate from Usage features. If you call to code that has not been created, you’ll get a compiler error because the symbol is not found. The error correction dialog now includes Generate from Usage options. The specific options available are based on the context. If it looks like a method, property or field, appropriate options are displayed. If it looks like a type, available options are creating a new class or a new type. Creating a new class will create a new file in your current project with an empty class using the symbol name. Creating a new type displays a dialog with many options for how the new type is created, including the project where it’s located. There are numerous improvements to debugging across all versions, but I think debugging deserves a future column to itself.

Source of Information : Visual Studio Magazine August 2010

Search Shortcuts in Visual Studio 2010

2010-09-07T00:18:00.000+08:00

Beyond Navigate To and Call Hierarchy, Visual Studio 2010 doesn’t include new search features, but existing features are wildly underutilized. Beyond a simple search, you can Find in Files, Find Symbols, use F3 and Ctl-F3 for the next and previous, and use the quick find box in the toolbar. Find in Files lets you specify the directory to search and the file types. Find Symbols lets you limit your search by platform and create custom component sets for searching as well as supporting both prefix and substring searches. And you can use RegEx in many search dialogs. There are two additional keyboard search tricks. If you select a set of characters in your code and hit Ctl-F3 or Ctl-Shift-F3, you’ll navigate forward and back through any matches. If you press Ctl-I or Alt-I—depending on your keyboard layout—you’ll enter incremental search mode and the cursor will change to an arrow and binoculars. In this mode, Visual Studio will refine your search as you type, moving to the next matching value. You can also hit F3 or Shift-F3 to navigate to the next or previous matches. Hitting these keys also ends incremental search mode and places your search text into the quick search box for easy reference or reuse.

Source of Information : Visual Studio Magazine August 2010

Tweaks to the Editor with Visual Studio 2010

2010-09-06T00:11:00.000+08:00

With previous versions of Visual Studio you could highlight a block by holding the Alt-Left mouse button and dragging. Now you have something useful to do with the block besides deleting it. Anything you type will simultaneously appear on all lines in the block. Outlining is improved in Visual Studio 2010. If you position over the vertical line representing the outline, the associated outline block appears shaded. If you click the line, this block collapses. You can also hide code within a method by selecting it, right-clicking and selecting Outline/Hide Selection. This can make it easier to understand complex methods—although breaking up complex methods remains a better strategy. Refactoring tools remain available in C# and through free third-party products for Visual Basic. The splitter in the upper-right corner of the edit window works a little differently in Visual Studio 2010. The cursor no longer changes when you pass over it, but you can still pull it down to see multiple locations in a single file within the same window. The left margin shows what files are changed. Yellow indicates changes that are not yet saved. Green marks lines that are saved, but don’t match the originally opened file—generally lines you can undo. A new orange color indicates lines that are the same as the original, but not yet saved. This generally happens when you undo back to the original, but an intermediate save means what’s saved doesn’t match what’s displayed.

Source of Information : Visual Studio Magazine August 2010

Better Navigation with Visual Studio 2010

2010-09-05T01:00:00.000+08:00

Navigating between your open windows continues to improve with each version of Visual Studio. Ctl-Tab displays a navigable list of available windows and Ctl-F6/Ctl-Shift-F6 navigates through tabs. Ctl-Minus and Ctl-Shift-Minus now offer a slightly different behavior, which navigates only through text editor (code) tabs, skipping designers. You can access the drop-down list of open tabs with Ctl-Alt-Down, or if this fails, key map searching on “EzMdi.”

Once dropped down, you can navigate to a specific tab either with the mouse or by typing the initial characters of the name. A subtle aspect of the drop-down is that the drop-down arrow changes when there are tabs out of view. The trick of navigating by typing the name also works when navigating in Solution Explorer. Windows themselves become more flexible in Visual Studio 2010. All windows can separate from Visual Studio, which is particularly useful when you drag them to a second monitor. Tool windows remain in a dockable state at all times, making rearrangement easier. The float option remains, but its purpose is to float a single item of a set of tabbed and docked windows. Dragging the title bar moves the set. In both cases, simply dragging to a dock location redocks, and dropping on a title bar adds to that tabbed set. Tool windows can now become tabs in the main window.

Within a code window you can navigate backward and forward using the back and forward buttons or keyboard shortcuts (which differ by keyboard layout). The Navigate To dialog box is new to Visual Studio 2010 and can be accessed via the Edit menu or a shortcut key. This feature has sometimes been called “Quick Search.” It allows navigation to any symbol (such as a type or method) in your project and is cached for very fast performance.

The search is based on a Pascal-style search, which assumes every capital letter or underscore in your symbol name delimits a word you might search on. A special trick is to include a space in your search string to find two different word parts based on a partial search. For example, “bi att” finds BizServiceAttribute and BizObjectAttribute. If you type capital letters, Visual Studio 2010 will evaluate them as an abbreviation, so BSA will also retrieve BizServiceAttribute as one of the matching options. This new dialog is especially useful when you’re not quite sure of the name. It enhances the benefits of good, semantic, multipart naming.

The Visual Studio 2010 editor has a feature that at first glance may seem a little odd. Hovering the cursor over a symbol highlights all matching symbols. This illustrates how symbols are used, particularly if you temporarily zoom out. What’s cool is you can navigate between the highlighted words using Ctl-Shift up and down arrows. If you don’t like this feature, you can turn it off in the Tool/Options page for each language.

C# and C++ have a special navigation feature called Call Hierarchy. Call Hierarchy allows exploration and navigation based on the ways methods are used, jumping to call sites and to called members. While this has some similarities to the runtime callstack, it’s available at design time and shows all potential paths, not just the single, currently executing path. Call Hierarchy is an extremely valuable tool. Hopefully, Visual Basic will support Call Hierarchy in the next version.

Source of Information : Visual Studio Magazine August 2010

Updated Project Dialog in Visual Studio 2010

2010-09-04T00:56:00.000+08:00

Once you’re ready to start a project, you’ll find an updated New Project dialog, where I’ve delineated the most easily overlooked features. You can finally search and sort items in this dialog! The search evaluates all available projects so you’ll see C# and Visual Basic projects both displayed. If you’d like to narrow it down to a particular project type, add C# or Visual Basic as a separate word at the end of your search string. The previous word doesn’t need to be complete; for example, “cl c#” finds the C# Class Library, C# Silverlight Class Library and several other project types.

You can select the target platform in the New Project dialog. If you develop Windows Presentation Foundation (WPF) or Windows Forms applications, you might be surprised to find the default target platform for Visual Studio 2010 is the Client Profile. This is a subset of the full Microsoft .NET Framework platform designed for faster and smaller installation. In most cases, this is a good choice for your application, but be prepared to change it if you’re missing aspects of the framework that you need. If you’ve seen a demo of Visual Studio 2010, you’ve probably seen zoom via the scroll wheel or control-shift-comma and period. It’s a flashy and easily misunderstood feature. Similar to Excel zoom, only the current tab zooms. The zoom doesn’t “stick.” The intention is not to change your font size overall, such as for a presentation, but to allow different views of different windows and at different times. You can zoom out to get the big picture or zoom in to see the details of your code.

I frequently want to change the font size for all of my text editor windows when I move from my external monitor to laptop screen, hook up to a projector, pair with someone, or when my eyes are just having a bad day. You can map a key to increase or decrease your font size for all of your code windows using an accessibility macro. Search keyboard mappings for “fontsize,” and you should find Macros.Samples.Accessibility.DecreaseTextEditorFontSize and its parallel InCreaseTextEditorFontSize. I map these to Alt-Minus and Alt-Equals, which are easy for me to remember. You can do this in Visual Studio 2008 and Visual Studio 2010.

Source of Information : Visual Studio Magazine August 2010

Personalize Your Layout in Visual Studio 2010

2010-09-03T00:52:00.000+08:00

Stop by the Fonts and Colors dialog, particularly if you do presentations. The default for selected text is difficult for some people to read, especially on some projectors. You can change this in any version of Visual Studio by selecting Text Editor/Selected Text and choosing black on a pale background such as yellow or a custom color. My eyes appreciate increasing the size of the small fonts used by default in tool windows and IntelliSense.

The Keyboard tab allows powerful personalization of your experience. You can set keystrokes for your favorite features, remap the keystrokes that you have trouble remembering, or map keystrokes to macros for truly custom behavior. You can also use the search feature of the keyboard dialog to see if a particular command is already mapped to a standard key in your keyboard layout. The keyboard-mapping page even allows exploration of what commands are available inside Visual Studio. A major improvement in Visual Studio 2010 is that right-click context menus now display mapped keystrokes.

If you’re a Visual Basic developer, consider how you want Ctl-Y to behave. The Visual Basic keyboard mapping retains the historic Cut Line behavior. However, programs from Office to Finale Notepad use Ctl-Y as the shortcut for Redo. With such a drastic difference in meaning, you might want to remap this key.

Other helpful settings in Visual Studio 2010 and Visual Studio 2008 include line numbers, save a new project when it’s created, open .XAML files in XAML View to avoid the designer delay, redirect debugger output to the Immediate window, or quiet the warning when files are modified outside the IDE by Expression Blend or external generation. Visual Basic programmers may want to select Option Strict for new projects to create a strongly typed experience by default.

In Visual Studio 2010 you can insert new tabs to the right of existing tabs for more consistency with programs like Internet Explorer. If you don’t like something that’s new in 2010, you can probably turn it off. Look for a “Show All Settings” checkbox at the bottom of the Options dialog if you chose Visual Basic as your development style. You can adjust your settings with confidence because if you mess things up entirely, you can reset it all in the Import/Export settings tab. You can also export settings for specific environments like pairing.

Source of Information : Visual Studio Magazine August 2010

IntelliTrace Debugging in a Nutshell

2010-09-02T01:31:00.000+08:00

IntelliTrace is a new debugging technology introduced in Visual Studio 2010 Ultimate. It’s based around low-overhead collection of debugger state at specific event points, exceptions, debugger stopping events and method enters and exits. From F5 debugging a user can move back in time to previous data collection points to examine collected data. In addition, the collected IntelliTrace file can be shared and the debugging session replayed on different machines.

When applications act up, you can break debugging and view the IntelliTrace events window. You’ll often see exceptions being thrown and caught that point to a possible issue or internal Microsoft .NET Framework calls that help convey what various frameworks are doing below the covers.

In the IntelliTrace options menu, a wide variety of IntelliTrace events can be configured for collection. These events were selected to cover a broad range of application types such as Windows Forms, ASP.NET and ADO.NET. A set of useful parameters has been selected for data collection at each event. With its ability to integrate with Microsoft Test Manager and save and debug from iTrace files, IntelliTrace can help close the “no repro” gap between developers and testers. A bug with an iTrace file attached is far more actionable for a developer. By integrating IntelliTrace into your testing workflows, you’ll improve life for both developers and testers.

By turning on the IntelliTrace calls information mode, data on method parameters and return values will be collected at all function enters and exits. This mode also provides several navigation features, such as searching for IntelliTrace results from source files and backward stepping to move between data collection points.

Source of Information : Visual Studio Magazine August 2010

Controlling Parallelization

2010-09-01T01:28:00.000+08:00

This article assumes that Parallel LINQ (PLINQ) will always do the right thing: choosing whether or not to run in parallel, for instance, and deciding how to distribute the components of a query over multiple threads. However, you can take control of PLINQ to force it to bend to your will by using the With* extensions.

If, when using the debugging tools described in this article, you notice that PLINQ is not processing a query in parallel, you can force it to do so by passing the ParallelExecutionMode. ForceParallelism value to the WithExecutionMode method:


ords = From o In le.Orders.AsParallel.
 WithExecutionMode(ParallelExecutionMode.ForceParallelism)

If you want to specify the number of threads to use (for instance, to try to ensure that one or more cores are left free) you can use the WithDegreeOfParallelism method. This example limits, or forces, the number of threads to three:


ords = From o In le.Orders.AsParallel.
 WithDegreeOfParallelism(3)

You can also terminate processing by using cancellation. You first create a CancellationTokenSource object and pass it to the WithCancellation extension:


Dim ctx As New System.Threading.CancellationTokenSource
ords = From o In le.Orders.AsParallel.
 WithCancellation(ctx.Token)
 Where o.RequiredDate > Now
 Select o

For Each ord As Order In ords
 totFreight += ord.Freight
 If totFreight > FreightChargeLimit Then
  ctx.Cancel()
 End If
Next

If you’re processing the results of a PLINQ query in a For...Each loop, exiting the loop automatically invokes cancellation.

XtraVerticalGrid Main Features

2010-08-31T01:43:00.000+08:00

With the release of the XtraVerticalGrid Suite, Developer Express introduces an entirely new way to develop elegant and highly functional user interfaces for your Windows Forms applications. Fully optimized for the utmost flexibility, the XtraVerticalGrid Suite will help you build stunning data entry forms with complete control over the information displayed on-screen.

The Suite comes with two controls that generally can be referred to as vertical grids, though their goals are different. The fist - the VerticalGridControl is a data-aware control, which provides an elegant solution to represent data source records as columns. The second control - PropertyGridControl - provides advanced capabilities to display settings of any object at runtime. The solutions implemented in the Suite will help you radically improve the UI of your applications. The control's layout, appearance and behavior settings can be flexibly customized depending upon your needs.

The feature list below offers you a glimpse into the XtraVerticalGrid Suite. The vertical grid controls included in the Suite have many features in common. Any features that are specific to a control are listed in the separate subsections below.

VerticalGridControl Features
• Full ADO+ Support - The VerticalGridControl takes full advantage of all the capabilities built into ADO.NET. With this data access architecture and the separation of internal data modules from data presentation, the control does not use any extra buffers in any of its data loading modes.

• Support for Data Lists - The VerticalGridControl can work with any source which supports the IList, ITypedList or IBindingList interface plus all the inherited interfaces.

• Multiple Layout Styles - These allow you to specify how bound data is represented within the control. You can choose between displaying a single record at a time, multiple records at a time, or a single record using multi-column format.

PropertyGridControl Features
• Binding to Any Object - After the object has been bound, the PropertyGridControl automatically retrieves its public properties and creates rows for all of them. You can then remove particular rows to hide specific fields.

• Support for Categories - Bound object properties can be grouped into categories. Nested categories are also supported.

• Specifying Default Editors to Edit Fields of Particular Types - The control enables you to specify in-place editors to represent and edit values of particular types. For instance, you can specify that the Boolean values will be represented using the CheckEdit control, instead of the standard ComboBox control with the traditional True and False items.

• Assigning Editors to Individual Rows - For any row you can override the default editor by assigning a specific in-place editor from the XtraEditors library.

Common Layout and Customization Features
• Runtime Layout Customization - End-users can customize the vertical grids at runtime in any way they want. They can hide/restore rows and create new data categories using the Customization Form, rearrange rows using drag-and-drop and resize rows

• Save And Load Layouts - This feature allows you to save the control's current layout between application runs, hence save the changes in the layout made by end-users.

• MultipleEditor Rows - A row of this type permits you to display multiple editors in a line.

• Nested Rows - The vertical grids support nested rows. Each row can have child rows, which can also have children, etc.

• Full Drag and Drop Support - The vertical grids support automatic internal drag-and-drop of rows and let you control drag-and-drop via events. You can also implement OLE drag-and-drop to send data from a grid to other controls and vice versa.

• Localization of Interface Elements - Like other Developer Express Windows Forms, the vertical grids use the Localization mechanism which allows you to localize interface elements into your language.

Common In-place Editing Features
• Over 20 Data Editors, which can be used standalone or in-place within the vertical grids.

• Editor Repository - You can setup a single in-place editor, for instance a pick image edit as an editor for a payment type field, and use it for as many vertical grids as you wish. When you use the repository and want to add a different type of credit card payment, you only need to change one in-place editor. See the EditorContainer.ExternalRepository property.

Common Appearance Features
• Various Paint Styles (Office2003, Flat, WindowsXP, Style3D, etc).

• Appearances - A powerful mechanism to control the entire look and feel of the Developer Express Windows Forms controls. You can specify the appearance of almost any visual element and even apply it conditionally via an event.

• Skins Support - Skins will bring a striking look and feel to your applications, far beyond the normal painting standards.

• Extended Gradient and AlphaBlending Support - You can apply gradient and alpha blending to any grid element at design time or runtime. The XtraVerticalGridBlending component help you customize alpha channels for various visual elements of the controls.

• Full Custom Draw Support - allows you to manually paint almost any element of the vertical grids.

Common Design-Time Features
• Advanced Design-Time Support - The XtraVerticalGrid Suite ships with an easy-to-use design time editor that allows you to control virtually every aspect of a vertical grid without having to write a single line of code. Instead of writing code to manage the appearance, you can concentrate on writing code to handle the really "interesting" tasks.

Source of Information : 2000-2010 Developer Express Inc. All rights reserved Documentation

XtraTreeList Main Features

2010-08-30T01:40:00.000+08:00

The XtraTreeList Suite is the first comprehensive TreeList control for Visual Studio.NET. It was built from the ground up using C# and is optimized to take full advantage of the .NET Framework. The XtraTreeList is a multi-purpose data visualization system that can display information as a TREE, a GRID, or a combination of both - in either data-bound or unbound mode. This unique synergy between a traditional grid and a traditional treeview allows you to create cutting-edge and visually appealing application interfaces for your end-users. The XtraTreeList places you in control of the development process and ensures that you can create function rich applications without having to write a single line of code.

The XtraTreeList fully exploits ADO.NET technologies. Its data source can use any class that implements an IList interface, and just like the XtraGrid, the XtraTreeList does NOT cache any data and as result has a small memory footprint and performs data operations as fast as your data can be obtained. In addition, the XtraTreeList fully supports our XtraEditors Library to provide you with a huge collection of individual editors - from drop down calendars to combo boxes.

Below is a list of the main features and benefits available to you when using the XtraTreeList control.

Data Specifics
• Support for Hierarchical Data Relationships - With the XtraTreeList, you can represent any self referenced data structure without hassle... In bound or un-bound mode. Please refer to the Tree Generation Algorithm in the XtraTreeList topic for details.

• Full ADO+ Support - The XtraTreeList takes full advantage of ADO+. By using this data access architecture and separation of internal data modules from data presentation, the XtraTreeList does not use any extra buffers, thus greatly improving performance and reducing memory use.

• Advanced Unbound Mode Support - The XtraTreeList works with any source which supports an IList or ITypedList interface, along with all inherited interfaces. Please see the Unbound Mode topic for more information.

• Export Data to and Import from XML - See the Export and Import Data methods.

• Dynamic Loading - Allows you to load only root nodes (rows) on start-up. Child nodes are loaded when their parents are expanded. Please see the Dynamic Loading in Unbound Mode topic for details on how this can be implemented.

• Binding to a Business Object - With this feature, you are able to bind the TreeList control to any object that represents a tree structure. You can do this by implementing the DevExpress.XtraTreeList.IVirtualTreeListData interface for the business object or via the TreeList's TreeList.VirtualTreeGetChildNodes and TreeList.VirtualTreeGetCellValue events. Please see the Binding to a Business Object topic for details.

Data Representation Specifics
• Automatic Sorting against Multiple Columns - With the XtraTreeList, you can sort against an unlimited number of columns, without writing a single line of code. Please refer to the Sorting topic for more information regarding the sorting algorithm implemented in the control.

• Filtering Nodes - This feature allows you to flexibly control the visibility of nodes. You can filter nodes based upon the contents of a column. It's also possible to handle the TreeList.FilterNode event to dynamically specify which nodes need to be currently displayed or hidden. Or you can change a node's visibility directly via the node's TreeListNode.Visible property.

• Custom Sorting - Allows you to implement a custom sorting algorithm by handling the TreeList.CompareNodeValues event.

• Custom Node Height and Runtime Node Resizing - You can implement a custom algorithm that sets different heights for different nodes or you can allow end-users to freely change the heights of nodes at runtime. See the TreeList.CalcNodeHeight and TreeListOptionsBehavior.ResizeNodes topics.

• Incremental Searching - This allows end-users to quickly locate the required information within the XtraTreeList by typing a search string within a non-editable column. See the TreeListOptionsBehavior.AllowIncrementalSearch and TreeListColumn.AllowIncrementalSearch properties.

• Auto Preview Pane - Permits you to display long text fields within the TreeList. Jump to the Preview Sections topic to get more information on this feature.

• Runtime Column Customization - The XtraTreeList provides a quick method of customizing the control's layout at runtime. End-users can hide specific columns and then restore them using drag and drop.

In-place Editing
• XtraEditors Library Integration - No more hassle or limits when it comes to using editors within a treeview. The XtraTreeList works in concert with our XtraEditors Library allowing you to use all our field editors (from date controls to combo boxes) directly within your TreeList. Please see the Inplace Editors topic for more details.

• Editor Repository - You can setup a single in-place editor, for instance a pick image edit as an editor for a payment type field, and use it for as many TreeLists or other Developer Express controls as you wish. When you use the repository and have to add a different credit card payment type, you only need to change it in one in-place editor.

Painting Specifics
• Support for Multiple Painting Schemes - WindowsXP, Flat, Style3D, Office2003, etc.

• Skins Support - Skins will bring a striking look and feel to your applications, far beyond the normal painting standards.

• Appearances - A powerful mechanism to control the entire look and feel of the TreeList, allowing you to customize appearance settings of almost any visual element. See the Appearances topic for more information.

• Style Conditions - You can apply appearances to cells conditionally to reflect certain states such as errors.

• Alpha Blending and Background Images - You can greatly improve the look & feel of your TreeList control by assigning a background image to it and using transparent element colors. Please see the Alpha Blending topic for details.

• Custom Painting - The XtraTreeList provides a set of events that enable you to perform custom painting of control elements. Using this feature, you have no limits in adjusting the control's look & feel. Please refer to the Custom Draw topic to see the ways in which this feature can be implemented.

Design-Time
• Advanced XtraTreeList Designer - The XtraTreeList control's designer provides access to the control's settings by categorizing them into separate pages. Thus you can quickly find appropriate options that control different aspects of the XtraTreeList. Jump to The XtraTreeList Designer topic to review the designer pages.

• Nodes Editor - This is an easy-to-use editor that allows you to add nodes at design time (used in unbound mode).

• Design-time column selection - Not only can you select columns in the Properties grid but also select them directly in the XtraTreeList at design time.

Miscellaneous
• Context Menus - Context menus provide end-users with quick access to the most common customization tasks: apply footer and row summaries, invoke column customization, apply best fit to columns and more. It's also possible to extend the built-in menus by implementing custom features via an event. Refer to the Context Menus topic for details.

• Column Header and Cell Hint Support.

• ErrorInfo Support - The XtraTreeList permits you to mark specific cells or entire nodes with error icons and so indicate the cells that contain invalid data. See the TreeList.SetColumnError topic for more information.

• Save and Load Layouts - By default, the XtraTreeList control enables end-users to customize the control's layout at runtime. To save the changes made into the layout by end-users between application runs you can use the TreeList's SaveLayoutTo... and RestoreLayoutFrom... methods. See the Saving and Restoring Layouts topic for more information.

• Printing (via the XtraPrinting Library).

• Localization of Every Interface Element. See the Localization topic.

• Export to XML, HTML, PDF, RTF, TXT and XLS - See the ExportTo... methods (for instance, TreeList.ExportToHtml).

Source of Information : 2000-2010 Developer Express Inc. All rights reserved Documentation

Parallel Processing Won’t Make Your Apps Faster

2010-08-29T01:08:00.000+08:00

One of the common misconceptions around multithreaded applications is that adding more threads to your application makes it run faster. Launching another thread doesn’t cause Windows to give your application more processing cycles—it just divides those cycles over more threads. In fact, on a single-processor computer, multithreading makes your application run slower by adding additional thread management tasks to your application’s overhead.

What multithreading does do is make your application more responsive. Where your application might otherwise have had to wait while some blocking task completes, with multithreading you can go and do something useful on another thread while waiting for the blocking task to complete. As a result, that second thread can let your application return a result earlier than it would have if the application had to wait for the blocking task to complete. On a single-core machine, it only made sense to use multithreading if a thread that was running for a blocked task didn’t need any processing cycles. If the thread wasn’t blocked, the two threads just ended up fighting for the limited number of processing cycles allocated to your application by Windows—and throwing away some of those cycles on activities like switching threads on and off the processor.

Multi-core processors change that paradigm. In a multi-core environment you can get Windows to give your application more processing cycles by transferring a thread to one of the other cores on the computer. And you don’t need to have a blocked thread to take advantage of multithreading—all threads can execute on their own core.

Parallel Extensions provides the programming constructs that allow you to tell the Microsoft .NET Framework which parts of your application can be run in parallel to get those benefits. In fact, Microsoft goes one step further: It claims that Parallel Extensions even changes the paradigm on single-core machines by reducing the overhead of managing multiple threads to the point where overhead simply doesn’t matter.

Source of Information : Visual Studio Magazine August 2010

Introducing PLINQ

2010-08-28T01:05:00.000+08:00

For business applications, PLINQ will shine anytime you have a LINQ query that involves multiple subqueries. If you’re joining rows from a table on a local database with rows from a table in another remote database, PLINQ can be very useful. In those situations, LINQ must run subqueries on each data source separately and then reconcile the results. PLINQ will distribute those subqueries over multiple processors-if any are available-so that they run simultaneously.

You won’t use fewer processor cycles to get your result-in fact, you’ll use more-but you’ll get your result earlier.

Even on a multi-core machine, PLINQ won’t always "parallelize" a query, for two reasons. One is that your application won’t always run faster when parallelized. The second reason is that, even with another layer of abstraction managing your threads, it’s still possible to shoot yourself in the foot-or someplace higher-with parallel processing. PLINQ checks for some unsafe conditions and won’t parallelize a query if it detects those conditions.

I’ll be pointing out some of the problems and conditions that PLINQ won’t detect but, in the end, it’s your responsibility to only use PLINQ where it won’t generate those untraceable bugs.

Processing PLINQ
Invoking PLINQ is easy: just add the AsParallel extension to your data source. This is an example from an application that joins a local version of the Northwind database to the remote version to get Orders based on customer information:


Dim ords As System.Linq.ParallelQuery(Of ParallelExtensions.Order)

ords = From c In le.Customers.AsParallel Join o In re.Orders.AsParallel
 On c.CustomerID Equals o.CustomerID
Where c.CustomerID = "ALFKI"

Select o

Because both data sources are marked AsParallel (and, in Join, if one data source is AsParallel, both must be) PLINQ will be used.

As with ordinary LINQ queries, PLINQ queries use deferred processing: Data isn’t retrieved until you actually handle it. That means while the LINQ query has been declared as parallel, parallel processing doesn’t occur until you process the results. So parallel execution doesn’t actually occur until the following block of code, which processes the due date on each of the retrieved Order objects:


For Each ord As Order In ords
 ord.RequiredDate.Value.AddDays(2)
Next

Under the hood, PLINQ will use one thread to execute the code in the For...Each loop, while other threads may be used to run the components of the query on as many processors as are available, up to a maximum of 64.

If the processing that I want to perform on each Order doesn’t share a state with the processing on other Orders, I can further improve responsiveness by using a ForAll loop. The ForAll is a method available from collections produced by a PLINQ query that accepts a lambda expression. Unlike a For...Each loop that executes on the application’s main thread, the operation passed to the ForAll method executes on the individual query threads generated by the PLINQ query:


ords.ForAll(Sub(ord)
 ord.RequiredDate.Value.AddDays(2)
End Sub)

Unlike my For...Each loop, which executes sequentially on a thread of its own, the code in my ForAll processing executes in parallel on the threads that are retrieving the Orders.

Managing Order
As with SQL-though everyone forgets it-order is not guaranteed in PLINQ. The order that results are returned in by PLINQ subqueries will depend on the unpredictable response time of the various threads. This query, for instance, is intended to retrieve the next five Orders to be shipped:


ords = From o In re.Orders.AsParallel
 Where o.RequiredDate > Now
 Select o
 Take (5)

If I don’t guarantee order, I’m going to get a random collection of Orders with required dates later than the current time-I may or may not get the first five Orders. To ensure that I’ll get the first five for both SQL and PLINQ, I need to add an Order By clause to the query that sorts the dates in ascending order. And, yes, that will throw away some of the benefits of PLINQ. Because results returned from multiple threads will turn up unexpectedly, PLINQ doesn’t really understand the concept of "previous item" and " next item." If, in your loop, you use the values of one item to process the next item in the loop, you may be introducing an error into your processing. To have items processed in the order that they appeared in the original data source, you’ll need to add the AsOrdered extension to the query.

For instance, if I wanted to "batch" my Orders into groups that were below a certain freight charge, I might write a loop like this:


For Each ord As Order In ords
 totFreight += ord.Freight
 If totFreight > FreightChargeLimit Then
 Exit For
 End If
 shipOrders.Add(ord)
Next

Because of the unpredictable order that items will be returned from parallel processes, I can’t guarantee that I’m putting anything but random Orders in each batch. To guarantee that items are processed in the order they appeared in my original data source, I have to add the AsOrdered extension to my data source:


ords = From o In re.Orders.AsParallel.AsOrdered
 Where o.RequiredDate > Now
 Select o

Source of Information : Visual Studio Magazine August 2010

Multi-Core Processors with .NET 4 and Visual Studio 2010

2010-08-27T01:49:00.000+08:00

If you want to take advantage of the power of multi-core machines, you need to start creating applications with parallel processing using PLINQ, the Task Parallel Library and the new features of Visual Studio 2010.

The old rule was, if you wanted to create a program with bugs that you could never hope to track down, you wrote it as a multithreaded application. All that has changed, thanks to the introduction of Microsoft Parallel Extensions for .NET, which provides a layer of abstraction on top of the Microsoft .NET Framework threading model.

Parallel Extensions follows the model Microsoft established with the transaction manager in COM applications and with the Entity Framework and LINQ in the area of data access. Parallel Extensions attempts to bring a sophisticated technology to the masses by building high-level support for a complex process into the .NET Framework. With multi-core processors becoming the norm, developers crave the ability to distribute their applications over all the cores on a computer.

You can access the power of Parallel Extensions either through Parallel LINQ (PLINQ) or through the Task Parallel Library (TPL). Both allow you to write one set of code for single- and multi-core computers and count on the .NET Framework to take maximum advantage of whatever platform your code eventually executes on, while protecting you from the usual pitfalls of creating multithreaded applications.

PLINQ extends LINQ queries to decompose a single query into multiple subqueries that are run in parallel rather than sequentially. TPL allows you to create loops with iterations running in parallel rather than one after another. While the declarative syntax of PLINQ makes it easier to create parallel processes, TPL-oriented operations will be, in general, more lightweight than PLINQ queries. In many ways, though, choosing between TPL and PLINQ is a lifestyle choice. If you think in terms of parallel loops rather than parallel queries, it can be easier for you to design a TPL solution than a PLINQ solution.

Source of Information : Visual Studio Magazine August 2010

Evolving User Experience with Microsoft Expression Studio 4

2010-08-26T01:43:00.000+08:00

People demand the best user experience with the technology they use every day—from PCs and TVs to mobile devices. The need for great applications and experiences has changed dramatically during the past few years. The bar of what constitutes a “great user experience” has been raised across a variety of devices, including mobile phones, Web browsers, gaming consoles and even kiosks. Regardless of the way content is being interacted with, one thing remains constant: The user experience needs to be relevant and engaging to meet customer expectations. Having a functional application simply isn’t enough anymore.

In June, Microsoft released Microsoft Expression Studio 4 with a list of new features to help developers and designers tackle this problem head on and eliminate ugly and unfriendly applications. Developers have often assumed that Expression is for designers only. That’s not the case. The truth is, Expression—and in particular Expression Blend—is a great tool for designers and developers who want to deliver great applications and user experiences.

This is particularly important today when considering how the traditional roles of designer and developer are quickly breaking down and becoming increasingly blurred. Expression Blend provides a toolset that effectively blends the design and development disciplines into one seamless workflow. It distinguishes itself by helping designers and developers collaborate and create great applications using their existing skills and current design tools.

One might ask, “How does Expression Blend work with a developer’s existing Microsoft Visual Studio toolset?” It does so by providing the tools that enable developers to evolve ideas from initial vision into a perfect solution through features such as SketchFlow (available in Expression Studio Ultimate), which conveys ideas through rapid prototyping, enabling better customer engagement, greater design flexibility and faster time to market. This is what makes Expression Blend and Visual Studio so powerful when used together: the flexibility between the two.

The Visual Studio center of gravity is code, which is the lens through which developers view a project, answer questions and solve problems. Expression Blend complements Visual Studio by providing a reverse perspective. The center of gravity around the application’s user experience determines how users interact with the application versus how it’s created. The behavior feature within Expression Blend allows developers to add interactivity without code. Additional features such as the Visual State Manager, sample data, easing functions, template editing and control styling enable developers and designers to think through problems in a different way, which gives them the opportunity to rapidly explore alternate ideas and solutions for their design dilemmas.

Expression Blend and Visual Studio share the same project format and do not require conversion of files; they’re like two sides of the same coin. One enables developers and designers to build robust, well-architected applications; the other delivers high-impact and effective user experiences. Developers and designers can switch environments quickly to explore and look for the best solution to a problem.

Creating great applications that meet the demands and expectations of end users takes passion, skill and inspiration. It also takes tools such as Expression and Visual Studio. MSDN subscribers are eligible to download Expression Studio 4. Those who are new to Expression Blend should check out the Microsoft OnRamp training program, which simplifies the Expression Blend training process by teaching basic fundamentals. Also, check out the trial version of Expression Studio 4 at Microsoft.com/expression and get started today!

Source of Information : Visual Studio Magazine August 2010

Two Productivity Tools for Visual Studio 2010

2010-08-25T01:29:00.000+08:00

The latest versions of CodeRush and ReSharper take advantage of the new features in Visual Studio 2010. Both tools continue to provide valuable— even essential—support for developers at a very reasonable price.

Both Developer Express CodeRush and JetBrains ReSharper are add-ins that extend Visual Studio by providing a plethora of tools that allow developers to create better code faster. I reviewed the Visual Studio 2008 versions of both products in the September 2009 (“Write Better Code, Faster, with ReSharper 4.5”) and October 2009 (“Turbo Charge Visual Studio with DevExpress CodeRush”) issues. While CodeRush is intended to support both C# and Visual Basic even-handedly, ReSharper targets the C# developer, though it also provides extensive support if you’re programming in Visual Basic. Perversely, for someone who still considers himself a Visual Basic programmer—though my client base is split 50/50 between C# and Visual Basic—I preferred ReSharper in those reviews because it didn’t require me to memorize as many keystroke combinations as CodeRush to access its functionality. With the release of Visual Studio 2010, both Developer Express and JetBrains have released new versions of their products. (You can read interviews with JetBrains developers [VisualStudioMagazine.com/tooltracker0810a] and DevExpress developers [VisualStudioMagazine.com/tooltracker0810b] on the complexities of developing for Visual Studio.)

Capitalize on CodeRush
The most obvious change in CodeRush is its use of Windows Presentation Foundation (WPF), or “WPF-ization.” The product’s developers have made a big effort to take advantage of the new Visual Studio screen display. One example: At the end of each method or property name, a small number appears that represents some measure of the method—you can choose between complexity and maintainability measures. If you haven’t upgraded to Visual Studio 2010, you can still access most of the new features of CodeRush: DevExpress developed an abstraction of the presentation layer for CodeRush that has both a Graphics Device Interface (GDI) and a WPF driver.

While the code generation and refactoring often get the most attention, I think it’s the interactive code analysis that’s most useful. Here again, the CodeRush exploitation of the Visual Studio WPF interface shines. For instance, the latest version of CodeRush marks every flow break (such as exit, return and end statements) with a small arrow. Hovering your mouse over the arrow flashes the line where control will be transferred to when the statement executes. If control transfers out of the method, a small animation flies to the method’s end. These kinds of tools help the developer understand what the code will actually do without having to step through it. When making changes to code, you need to find where the code is called from. New navigation features in CodeRush enable you to skip through your code to all the calls to any method just by selecting an option from a context menu. Tab and Shift-Tab allow you to work through all the overloads for a method. When you invoke any of these navigation options, CodeRush pops up a tab showing all of the navigation options available to you, reducing the need to remember keystrokes.

Reach Higher with ReSharper
If CodeRush is expanding its feature set within its existing support, ReSharper is expanding its range. As an ASP.NET developer, I especially like the new ReSharper File Structure window, which goes beyond the Visual Studio Document outline to support navigating through pages of complex HTML. The “Navigate to related files” menu choice lets me get to all the files related to a Web page (graphics, stylesheets, user controls, JavaScript files and so on) without scrolling up and down through the Solution Explorer window. ReSharper has also added support specifically for ASP.NET Model-View-Controller (MVC) developers.

That’s not to diminish the code generation and refactoring abilities that come with ReSharper. If you’ve been putting off becoming an expert in LINQ, for instance, the ReSharper capacity to automatically refactor C# foreach loops into LINQ queries is a good way to get started. ReSharper, like CodeRush, has always offered a wealth of recommendations about ways you can improve your code. The latest version lets you define your own rules to recognize—and even implement— project-specific best practices. In addition to getting this advice as you type, you can also run inspections of whole projects.

Get Better Code
Both packages offer separate Options dialogs to allow you to enable, disable and customize features. When you install CodeRush, you get an option to work in a “newbie” mode, which provides more prompting, or in an “expert” mode. ReSharper offers, on installation, three options for your keyboard: one for experienced Visual Studio developers, one for Java developers and one that does no mapping to your keyboard. Both DevExpress and JetBrains have tuned their add-ins to reduce the demands on your computer, but all of this additional functionality comes at a price: You may find yourself having to turn off features that you don’t need to improve responsiveness.

CodeRush for Visual Studio 2010 10.1 and Refactor! Pro for Visual Studio 2010 10.1
Developer Express Inc.
Web: Devexpress.com
Phone: 818-844-3383
Price: $249.99
Quick Facts: Productivity feature add-ins for Visual Studio with extensive refactoring support
Pros: Extends powerful refactoring tools with additional support for developers working with complex applications and on-the-fly code analysis
Cons: Taking advantage of all the features requires a powerful CPU; many developers will need to pick the options they want and turn off others

ReSharper 5.0
JetBrains
Web: Jetbrains.com
Phone: 888-672-1076
Price: $199 Personal license for Full Edition; Organization and academic licenses available Quick Facts: A productivity feature add-in for Visual Studio targeted at C# developers
Pros: Extends the power of the original tool into new environments (especially ASP.NET) and up the value chain into project maintenance
Cons: Taking advantage of all the features requires a powerful CPU; many developers will need to pick the options they want and turn off others

Source of Information : Visual Studio Magazine August 2010

.NET 4.0 New Types

2010-08-24T01:09:00.000+08:00

Now that the lowdown changes are out of the way, lets look at some of the new types in .NET 4.0 and modifications to existing classes and methods.

BigInteger
Working with really big numbers in .NET can get a bit strange. For example, try the following example (without advanced options such as overflow checking) and you might be surprised at the result you get:
<pre class="brush:csharp">
int a = 2000000000;
Console.WriteLine(a * 2);
Console.ReadKey();
</pre>
Surely the result is 4000000000? Running this code will give you the following answer:
-294967296

This issue occurs due to how this type of integer is represented in binary and the overflow that occurs. After the multiplication, the number gets bigger than this type can handle, so it actually becomes negative.

OK, so not many applications will need to hold values of this magnitude. But for those that do, .NET 4.0 introduces the BigInteger class (in the System.Numerics namespace) that can hold really big numbers.

BigInteger is an immutable type with a default value of 0 with no upper or lower bounds. This upper value is subject to available memory, of course, and if exceeded, an out-of-memory exception will be thrown. But seriously, what are you holding? Even the U.S. national debit isn’t that big.

BigIntegers can be initialized in two main ways:
<pre class="brush:csharp">
BigInteger bigIntFromDouble = new BigInteger(4564564564542332);
BigInteger assignedFromDouble = (BigInteger) 4564564564542332;
</pre>
BigInteger has a number of useful (and self-explanatory) methods not found in other numeric types:
• IsEven()
• IsOne()
• IsPowerOfTwo()
• IsZero()
• IsSign()

Lazy<T>
Lazy<T> allows you to easily add lazy initialization functionality to your variables. Lazy initialization saves allocating memory until the object is actually used. So if you never end up accessing your object, you have avoided using the resources to allocate it. Additionally, you have spread out resource allocation through your application’s life cycle, which is important for the responsiveness of UI-based applications. Lazy<T> couldn’t be easier to use:
<pre class="brush:csharp">
Lazy<BigExpensiveObject> instance;
</pre>

Lazy has implications for multithreaded scenarios. Some of the constructors for the Lazy type have an isThreadSafe parameter (see MSDN for more details of this: http://msdn.microsoft.com/en-us/library/dd997286%28VS.100%29.aspx).

Memory Mapping Files
A memory mapped file maps the contents of a file into memory, allowing you to work with it in a very efficient manner. Memory mapped files can also be used for interprocess communication, allowing you to share information between two applications:

Let’s see how to use memory mapped files inter process communication:

1. Create a new console application called Chapter4.MemoryMappedCreate.

2. Add the following using statements:
<pre class="brush:csharp">
using System.IO;
using System.IO.MemoryMappedFiles;
</pre>
3. Enter the following code in the Main() method:
<pre class="brush:csharp">
//Create a memory mapped file
using (MemoryMappedFile MemoryMappedFile = MemoryMappedFile.CreateNew("test", 100))
{
MemoryMappedViewStream stream = MemoryMappedFile.CreateViewStream();
using (BinaryWriter writer = new BinaryWriter(stream))
{
er.Write("hello memory mapped file!");
}
Console.WriteLine("Press any key to close mapped file");
Console.ReadKey();
}
</pre>
4. Add another Console application called Chapter4.MemoryMappedRead to the solution.

5. Add the following using statements:
<pre class="brush:csharp">
using System.IO;
using System.IO.MemoryMappedFiles;
</pre>
6. Enter the following code in the Main() method:
<pre class="brush:csharp">
//Read a memory mapped file
using (MemoryMappedFile MemoryMappedFile = MemoryMappedFile.OpenExisting("test"))
{
using (MemoryMappedViewStream Stream = MemoryMappedFile.CreateViewStream())
{
BinaryReader reader = new BinaryReader(Stream);
Console.WriteLine(reader.ReadString());
}
Console.ReadKey();
}
</pre>
7. You have to run both projects to demonstrate memory mapped files. First, right-click the project.MemoryMappedCreate and select Debug -> Start new instance. A new memory mapped file will be created and a string written to it.

8. Right-click the project Chapter4.MemoryMappedRead and select Debug -> Start new instance. You should see the string hello memory mapped file! read and printed from the other project.

The other main use of memory mapped files is for working with very large files. For an example, please refer to this MSDN article: http://msdn.microsoft.com/enus/library/system.io.memorymappedfiles.memorymappedfile(VS.100).aspx.

SortedSet<T>
Sorted set is a new type of collection in the System.Collections.Generic namespace that maintains the order of items as they are added. If a duplicate item is added to a sorted set, it will be ignored, and a value of false is returned from the SortedSet’s Add() method. The following example demonstrates creating a sorted list of integers with a couple of duplicates in:
<pre class="brush:csharp">
SortedSet<int> MySortedSet = new SortedSet<int> { 8, 2, 1, 5, 10, 5, 10, 8 };
</pre>

ISet<T> Interface
.NET 4.0 introduces ISet<T>, a new interface utilized by SortedSet and HashSet and surprisingly enough for implementing set classes.

Tuple
A tuple is a typed collection of fixed size. Tuples were introduced for interoperability with F# and IronPython, but can also make your code more concise.

Tuples are very easy to create:
<pre class="brush:csharp">
Tuple<int, int, int, int, int> MultiplesOfTwo = Tuple.Create(2, 4, 6, 8, 10);
</pre>
Individual items in the tuple can then be queried with the Item property:
<pre class="brush:csharp">
Console.WriteLine(MultiplesOfTwo.Item2);
</pre>
Tuples might contain up to seven elements; if you want to add more items, you have to pass in another tuple to the Rest parameter:
<pre class="brush:csharp">
var multiples = new Tuple<int, int, int, int, int, int, int,Tuple<int,int,int>>(2, 4, 6, 8,
10, 12, 14, new Tuple<int,int,int>(3,6,9));
</pre>
Items in the second tuple can be accessed by querying the Rest property:
<pre class="brush:csharp">
Console.WriteLine(multiples.Rest.Item1);
</pre>

System.Numerics.Complex
Mathematicians will be glad of the addition of the new Complex type: a structure for representing and manipulating complex numbers, meaning that they will no longer have to utilize open source libraries or projects. Complex represents both a real and imaginary number, and contains support for both rectangular and polar coordinates:
<pre class="brush:csharp">
Complex c1 = new Complex(8, 2);
Complex c2 = new Complex(8, 2);
Complex c3 = c1 + c2;
</pre>
And I am afraid my math skills aren’t up to saying much more about this type, so let’s move on.

System.IntPtr and System.UIntPtr
Addition and subtraction operators are now supported for System.IntPtr and System.UIntPtr. Add()() and Subtract() methods have also been added to these types.

Tail Recursion
The CLR contains support for tail recursion, although this is only currently accessible through F#.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Exception Handling

2010-08-23T00:50:00.000+08:00

Exception handling has been improved in .NET 4.0 with the introduction of the System.Runtime. ExceptionServices namespace, which contains classes for advanced exception handling.

CorruptedStateExceptions
Many developers (OK, I might have done this, too) have written code such as the following:


try
{
// do something that may fail
}
catch(System.exception e)
{
...
}

This is almost always a very naughty way to write code because all exceptions will be hidden. Hiding exceptions you don’t know about is rarely a good thing, and if you do know about them, you should inevitably be handling them in a better way. Additionally, there are some exceptions that should never be caught (even by lazy developers) such as lowdown beardy stuff such as access violations and calls to illegal instructions. These exceptions are potentially so dangerous that it’s best to just shut down the application as quick as possible before it can do any further damage.

So in .NET 4.0, corrupted state exceptions will never be caught even if you specify a try a catch block. However, if you do want to enable catching of corrupted state exceptions application-wide (e.g., to route them to an error-logging class), you can add the following setting in your applications configuration file:

LegacyCorruptedStateExceptionsPolicy=true

This behavior can also be enabled on individual methods with the following attribute:


[HandleProcessCorruptedStateExceptions]

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Native Code Enhancements

2010-08-22T01:36:00.000+08:00

I will not be covering changes to native code, so I have summarized some of the important changes here:

• Support for real-time heap analysis.

• New integrated dump analysis and debugging tools.

• Tlbimp shared source is available from codeplex (http://clrinterop.codeplex.com/).

• Support for 64-bit mode dump debugging has also been added.

• Mixed mode 64-bit debugging is now supported, allowing you to transition from managed to native code.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Native Image Generator (NGen)

2010-08-21T00:34:00.000+08:00

NGen is an application that can improve the startup performance of managed applications by carrying out the JIT work normally done when the application is accessed. NGen creates processor optimized machine code (images) of your application that are cached. This can reduce application startup time considerably. Prior to .NET 4.0, if you updated the framework or installed certain patches, it was necessary to NGen your application all over again. But no longer; through a process known as "targeted" patching, regenerating images is no longer required.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Monitoring and Profiling

2010-08-20T01:30:00.000+08:00

.NET 4.0 introduces a number of enhancements that enable you to monitor, debug, and handle exceptions:

• .NET 4.0 allows you to obtain CPU and memory usage per application domain, which is particularly useful for ASP.NET applications (see Chapter 10).

• It is now possible to access ETW logs (no information available at time of writing) from .NET.

• A number of APIs have been exposed for profiling and debugging purposes.

• No longer must profilers be attached at application startup; they can be added at any point. These profilers have no impact and can be detached at any time.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Security

2010-08-19T01:27:00.000+08:00

In previous releases of .NET, the actions code could perform could be controlled using Code Access Security (CAS) policies. Although CAS undoubtedly offered much flexibility, it could be confusing to use and didn’t apply to unmanaged code. In .NET 4.0, security is much simpler.

Transparency Model
The transparency model divides code into safe, unsafe, and maybe safe code (depending on settings in the host the application is running in). .NET has a number of different types of hosts in which applications can live, such as ASP.NET, ClickOnce, SQL, Silverlight, and so on.
Prior to .NET 4.0, the transparency model was used mainly for auditing purposes (Microsoft refers to this as transparency level 1) and in conjunction with code checking tools such as FxCop. The transparency model divides code into three types:
• Transparent
• Safe critical
• Critical

Transparent Code
Transparent code is safe and verifiable code such as string and math functions that will not do anything bad to users’ systems. Transparent code has the rights to call other transparent code and safe critical code. It might not call critical code.

Safe Critical Code
Safe critical code is code that might be allowed to run depending on the current host settings. Safe critical code acts as a middle man/gatekeeper between transparent and critical code verifying each request. An example of safe critical code is FileIO functions that might be allowed in some scenarios (such as ASP.NET) but not in others (such as Silverlight).

Critical Code
Critical code can do anything and calls such as Marshal come under this umbrella.

Safe Critical Gatekeeper
Transparent code never gets to call critical code directly, but has to go via the watchful eye of safe critical code.

Why Does It Matter?
If your .NET 4.0 application is running in partial trust, .NET 4.0 will ensure that transparent code can call only other transparent and safe critical code (the same as the Silverlight security model). When there is a call to safe critical code, a permission demand is made that results in a check of permissions allowed by the current host. If your application does not have permissions, a security exception will occur.

Security Changes
There are a number of security changes:
• Applications that are run from Windows Explorer or network shares run in full trust. This avoids some tediousness because prior to .NET 4.0 local and network applications would run with different permission sets.

• Applications that run in a host (for example, ASP.NET, ClickOnce, Silverlight, and SQL CLR) run with the permissions the host grants. You thus need worry only that the host grants the necessary permissions for your application. Partial trust applications running within a host are considered transparent applications (see following) and have various restrictions on them.

• Runtime support has been removed for enforcing Deny, RequestMinimum, RequestOptional, and RequestRefuse permission requests. Note that when you upgrade your applications to use .NET 4.0, you might receive warnings and errors if your application utilizes these methods. As a last resort, you can force the runtime to use legacy CAS policy with the new NetFx40_LegacySecurityPolicy attribute. For migration options, see http://msdn.microsoft.com/en-us/library/ee191568(VS.100).aspx.

• For un-hosted code, Microsoft now recommends that security policies are applied by using Software Restriction Policies (SRPs,), which apply to both managed and unmanaged code. Hosted code applications (e.g., ASP.NET and ClickOnce) are responsible for setting up their own policies.

SecAnnotate
SecAnnotate is a new tool contained in the .NET 4.0 SDK that analyzes assemblies for transparency violations.

APTCA and Evidence
I want to highlight two other changes (that probably will not affect the majority of developers):

• Allow Partially Trusted Callers Attribute (APTCA) allows code that is partially trusted (for example, web sites) to call a fully trusted assembly and has a new constructor that allows the specification of visibility with the PartialTrustVisibilityLevel enumeration.

• A new base class called Evidence has been introduced for all objects to be used that all evidence will derive from. This class ensures that an evidence object is not null and is serializable. A new method has also been added to the evidence list, enabling querying of specific types of evidence rather than iterating through the collection.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Globalization

2010-08-18T01:06:00.000+08:00

Globalization is becoming increasingly important in application development. The .NET 4.0 Framework now supports a minimum of 354 cultures (compared with 203 in previous releases??now with new support for Eskimos/Inuits??and a whole lot more).

A huge amount of localization information is compiled into the .NET Framework. The main problem is that the .NET Framework doesn’t get updated that often, and native code doesn’t use the same localization info.

This changes in .NET 4.0 for Windows 7 users because globalization information is read directly from the operating system rather than the framework. This is a good move because it presents a consistent approach across managed/unmanaged applications. For users not lucky enough to be using Windows 7 (it’s good; you should upgrade), globalization information will be read from the framework itself as per usual. Note that Windows Server 2008 will still use the localized .NET 4.0 store.

Globalization Changes in .NET 4.0
There have been a huge number of globalization changes; many of them will affect only a minority of users. For a full list, please refer to http://msdn.microsoft.com/en-us/netframework/dd890508.aspx.

I do want to draw your attention to some of the changes in .NET 4.0:

• Neutral culture properties will return values from the specific culture that is most dominant for that neutral culture.

• Neutral replacement cultures created by .NET 2.0 will not load in .NET 4.0.

• Resource Manager will now refer to the user’s preferred UI language instead of that specified in the CurrentUICultures parent chain.

• Ability to opt in to previous framework versions’ globalization-sorting capabilities.

• zh-HK_stroke, ja-JP_unicod, and ko-KR_unicod alternate sort locales removed.

• Compliance with Unicode standard 5.1 (addition of about 1400 characters).

• Support added for following scripts: Sundanese, Lepcha, Ol Chiki, Vai, Saurashtra, Kayah Li, Rejang, and Cham.

• Some cultures display names changed to follow naming convention guidelines: (Chinese, Tibetan (PRC), French (Monaco), Tamazight (Latin, Algeria), and Spanish (Spain, International Sort).

• Parent chain of Chinese cultures now includes root Chinese culture.

• Arabic locale calendar data updated.

• Culture types WindowsOnlyCultures and FrameworkCultures now obsolete.

• CompareInfo.ToString()() and TextInfo.ToString()() will not return locale IDs because Microsoft wants to reduce this usage.

• Miscellaneous updates to globalization properties such as currency, date and time formats, and number formatting.

• Miscellaneous updates to globalization properties such as currency, date and time formats, and number formatting.

TimeSpan Globalized Formatting and Parsing
TimeSpan now has new overloaded versions of ToString()(), Parse()(), TryParse()(), ParseExact()(), and TryParseExact()() to support cultural sensitive formatting. Previously, TimeSpan’s ToString() method would ignore cultural settings on an Arabic machine, for example.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Threading

2010-08-17T01:57:00.000+08:00

Threading has been tweaked in .NET 4.0, with the thread pool switching to a lock-free data structure (apparently the queue used for work items is very similar to ConcurrentQueue). This new structure is more GC-friendly, faster, and more efficient. Prior to .NET 4.0, the thread pool didn’t have any information about the context in which the threads were created, which made it difficult to optimize (for example, whether one thread depends on another). This situation changes in .NET 4.0 with a new class called Task that provide more information to the thread pool about the work to be performed thus allowing it to make better optimizations.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Garbage Collection

2010-08-16T00:55:00.000+08:00

Garbage collection is something you rarely have to worry about in our nice managed world, so before you look at what has changed in .NET 4.0, let’s quickly recap how GC currently works to put the new changes in context.

Garbage Collection Prior to .NET 4.0
As you probably know, the CLR allocates memory for your applications as they require it and assumes an infinite amount of memory is available (you wish). This is a mad assumption, so a process called the garbage collector (GC) is needed in order to clean up unused resources. The GC keeps an eye on available memory resources and will perform a cleanup in three situations:
- When a threshold is exceeded
- When a user specifically calls the garbage collector
- When a low system memory condition occurs

To make this as efficient as possible, the GC divides items to be collected into "generations." When an item is first created, it is considered a generation 0 item (gen 0), and if it survives subsequent collections (it is still in use), it is promoted to a later generation: generation 1 and later generation 2.

This division allows the garbage collector to be more efficient in the removal and reallocation of memory. For example, generation 0 items mainly consist of instance variables that can be quickly removed (freeing resources earlier) while the older generations contain objects such as global variables that will probably stick around for the lifetime of your application. On the whole, the GC works very well and saves you writing lots of tedious cleanup code to release memory.

The GC operates in a number of modes: workstation, concurrent workstation (default for multicore machines), and server. These modes are optimized for different scenarios. For example, workstation is the default mode and is optimized for ensuring that your applications have a quick response time (important for UI-based applications) while server mode is optimized for throughput of work (generally more important for server type applications). Server mode does pause all other managed threads during a garbage collection, however. If server mode were used for a Windows Forms application, this
collection could manifest itself as intermittent pauses, which would be very annoying.

Garbage Collection in .NET 4.0
So what’s changed then? Prior to .NET 4.0, a concurrent workstation GC could do most but not all of a generation 0 and 1 collection at the same time as a generation 2 collection. The GC was also unable to start another collection when it was in the middle of a collection which meant that only memory in the current segment could be reallocated. In .NET 4.0, however, concurrent workstation GC collection is replaced by background garbage collection. The simple explanation (and GC gets very complex) is that background garbage collection allows another GC (gen 0 and 1) to start at the same time as an existing full GC (gen 0, 1, and 2) is running, reducing the time full garbage collections take. This means that resources are freed earlier and that a new memory segment could be created for allocation if the current segment is full up. Background collection is not something you have to worry about??it just happens and will make your applications perform more quickly and be more efficient, so it’s yet another good reason to
upgrade your existing applications to .NET 4.0. Background collection is not available in server mode GC, although the CLR team has stated they are aiming to achieve this in the next version of the framework. The GC team has also done work to ensure that garbage collection works effectively on up to 128 core machines and improved the GC’s efficiency, reducing the time needed to suspend managed threads For more information and a detailed interview with the GC team, please refer to http://blogs.msdn.com/ukadc/archive/2009/10/13/background-and-foreground-gc-in-net-4.aspx and http://channel9.msdn.com/shows/Going+Deep/Maoni-Stephens-and-Andrew-Pardoe-CLR-4-Inside-Background-GC/.

GC.RegisterForFullGCNotification()
It is worth noting that from .NET 3.5SP1, the CLR has a method called GC.RegisterForFullGCNotification() that lets you know when a generation 2 or large heap object collection occurs in your applications. You might want to use this information to route users to a different server until the collection is complete, for example.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Dot Net Framework 4 New CLR

2010-08-15T01:08:00.001+08:00

The last two releases of.NET (3.0 and 3.5) have been additive releases building on top of the functionality available in CLR version 2.0. NET 4.0 however has a new version of the CLR! So you can happily install .NET 4.0 without fear that it will affect your existing .NET applications running on previous versions of the framework.

ASP.NET
When using IIS7, the CLR version is determined by the application pool settings. Thus you should be able to run .NET 4.0 ASP.NET applications side by side without fear of affecting existing ASP.NET sites.

What Version of the CLR Does My Application Use?
It depends; applications compiled for earlier versions of the framework will as before use the same version they were built on if it's installed. If, however, the previous framework version is not available, the user will now be offered a choice about whether to download the version of the framework the application was built with or whether to run using the latest version. Prior to .NET 4.0, the user wouldn’t be given this choice with the application using the latest version available.

Specifying the Framework to Use
Since almost the beginning of .NET (well, .NET Framework 1.1), you can specify the version your application needs to use in the App.config file (previously as requiredRuntime):

The version property supports the following settings:
- v4.0 (framework version 4.0)
- v2.0.50727 (framework version 3.5)
- v2.0.50727 (framework version 2.0)
- v1.1.4322 (framework version 1.1)
- v1.0.3705 (framework version 1.0)

If this setting is left out, the version of the framework used to build the application is used (if available). When the supportedRuntime property is set, if you try to run the application on a machine that doesn’t have the CLR version specified.

VB.NET Command-Line Compiler
The compiler has a new /langversion switch option that allows you to tell the compiler to use a particular framework version. It currently accepts parameters 9, 9.0, 10, and 10.0. vbc /langversion:9.0 skynet.vb

Improved Client Profile
Client profile is a lean, reduced-functionality version of the full .NET Framework that was first introduced in .NET 3.5SP1. Functionality that isn’t often needed is removed from the client profile. This results in a smaller download and reduced installation time for users. At the time of writing, Microsoft has reduced the size of the client profile to around 34 MB, although it intends to minimize it even further for the final release. The .NET 4.0 client profile is supported by all environments that support the full .NET Framework and is redistributable (rather than web download only) and contains improvements to add/remove program entries, unlike the version available in .NET 3.5SP1.

To use the client profile in your application, open the project Properties page, select the Application tab, and on the Target framework drop-down menu select .NET Framework 4.0 Client Profile. Note that in VB.NET, this option is in the Compile??Advanced Compile Options tab. Client profile is the default target framework option in many VS2010 project types such as Windows Forms and Console. This is important to remember because sometimes you will need functionality not available in the client profile and be confused as to why various options are not available in the Add Reference menu.
For more information about client profile, please consult http://blogs.msdn.com/jgoldb/archive/2009/05/27/net-framework-4-client-profile-introduction.aspx.

In-Process Side-by-Side Execution
Prior to .NET 4.0, COM components would always run using the latest version of the .NET Framework installed by the user. This could cause some issues, for example at some of the PDC08 presentations Microsoft cites an Outlook add-in that contained a thread variable initialization bug. The add-in worked
correctly in .NET 1.0, but after the clever guys in the CLR team made performance improvements to the threading pool in .NET 1.1, the add-in left many Microsoft executives unable to read their e-mail (some cynics argued that little productivity was lost).

Obviously you want to fix this bug, but it is vital to know that your application will run in the same manner as when you tested it. In-process side-by-side execution ensures that COM components run using the version of the framework they were developed for.

Prior to .NET 4.0, COM components would run using the latest version of the .NET Framework installed. You can now force COM components to use a specific framework version by adding the supportedRuntime section to App.config:

You can also force components to use the latest version of the .NET Framework with the following configuration:

For more information, please refer to http://msdn.microsoft.com/en-gb/library/ee518876(VS.100).aspx. Developers creating .NET components should note that their libraries will always run using the same framework version of the app domain they are running in if loading through a reference or call to Assembly.Load(). For example, libraries built in a previous version of .NET used in an application upgraded to .NET 4.0 will run using .NET 4.0. This might not be the case for unmanaged code, however.

Source of Information : Apress Introducing dot NET 4.0 with Visual Studio 2010

Changing the background color of the rows in the Schedule [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-14T01:08:00.000+08:00

This tutorial is intended to show how to change the background color of the rows in the Schedule control using the WorkingHourSchema object

The following code shows how to format the rows based on the day of the week

In VB:


'Create a new ScheduleHourRange object to specify the format style settings and the

'time and days when the format style will be applied

Dim hourRange As New ScheduleHourRange()



'Specify the start and end time that you want to format     

hourRange.EndTime = New TimeSpan(10, 0, 0)

hourRange.StartTime = New TimeSpan(8, 0, 0)



'Specify the days of the week that you want to format

hourRange.DayOfWeek = ScheduleDayOfWeek.Monday Or ScheduleDayOfWeek.Tuesday Or _

  ScheduleDayOfWeek.Wednesday Or ScheduleDayOfWeek.Thursday Or ScheduleDayOfWeek.Friday



'Set the format style that you want to apply

hourRange.FormatStyle.BackColor = Color.Red



'Add the ScheduleHourRange to the WorkingHoursRange collection of the WorkingHourSchema

Me.Schedule1.WorkingHourSchema.WorkingHoursRange.Add(hourRange)

In C#


//Create a new ScheduleHourRange object to specify the format style settings and the

//time and days when the format style will be applied

ScheduleHourRange hourRange = new ScheduleHourRange();



//Specify the start and end time that you want to format     

hourRange.EndTime = new TimeSpan(10, 0, 0);

hourRange.StartTime = new TimeSpan(8, 0, 0);



//Specify the days of the week that you want to format

hourRange.DayOfWeek = ScheduleDayOfWeek.Monday | ScheduleDayOfWeek.Thursday | ScheduleDayOfWeek.Wednesday | ScheduleDayOfWeek.Thursday | ScheduleDayOfWeek.Friday;



//Set the format style that you want to apply

hourRange.FormatStyle.BackColor = Color.Red;



//Add the ScheduleHourRange to the WorkingHoursRange collection of the WorkingHourSchema

this.Schedule1.WorkingHourSchema.WorkingHoursRange.Add(hourRange);

The following code shows how to use the Exceptions collection to format the rows for a specific Date

In VB:


'Create a new WorkingHourException

Dim exception As New WorkingHourException()



'Specify the date range where you want to give the format

'Note: The date range must be of at least one day, and use the StartTime and EndTime 'properties of the HourRange to set the time of the day where the format will be applied

exception.DateRange = New DateRange(New DateTime(2006, 1, 15), New DateTime(2006, 1, 16))



'Specify the start and end time that you want to format        exception.HourRange.EndTime = New TimeSpan(14, 0, 0)

exception.HourRange.StartTime = New TimeSpan(10, 0, 0)

'Set the format style that you want to apply

exception.HourRange.FormatStyle.BackColor = Color.Red



'Add the WorkingHourException to the Exceptions collection of the WorkingHourSchema

Me.Schedule1.WorkingHourSchema.Exceptions.Add(exception)

In C#


//Create a new WorkingHourException

WorkingHourException exception = new WorkingHourException();



//Specify the date range where you want to give the format

//Note: The date range must be of at least one day, and use the StartTime and EndTime //properties of the HourRange to set the time of the day where the format will be applied

exception.DateRange = new DateRange(new DateTime(2006, 1, 16), new DateTime(2006, 1, 17));



//Specify the start and end time that you want to format     

exception.HourRange.EndTime = new TimeSpan(14, 0, 0);

exception.HourRange.StartTime = new TimeSpan(10, 0, 0);

//Set the format style that you want to apply

exception.HourRange.FormatStyle.BackColor = Color.Green;



//Add the WorkingHourException to the Exceptions collection of the WorkingHourSchema

this.Schedule1.WorkingHourSchema.Exceptions.Add(exception);

The following code shows how to use the RecurrencePattern property of the ScheduleHourRange object to apply the format style for the rows based on a recurrence pattern

In VB:


Dim recurrencePattern As New WorkingHourRecurrencePattern()

'Call the BeginEdit before changing the properties of the RecurrencePattern

recurrencePattern.BeginEdit()





'Specify the recurrence pattern. In this case the 10th of every month is the date that 'will be formatted

recurrencePattern.SetDefaultValuesForDate(DateTime.Today)

recurrencePattern.PatternStartDate = DateTime.Today

recurrencePattern.RecurrenceEndMode = RecurrenceEndMode.NoEndDate

recurrencePattern.RecurrenceType = RecurrenceType.Monthly

recurrencePattern.StartTime = New TimeSpan(8, 0, 0)

recurrencePattern.EndTime = New TimeSpan(10, 0, 0)

recurrencePattern.DayOfMonth = 10



recurrencePattern.EndEdit()



'Create the new ScheduleHourRange that will be added to the WorkingHourSchema

Dim hourRange As New ScheduleHourRange()



'Set the RecurrencePattern that will be used

hourRange.RecurrencePattern = recurrencePattern



'Set the format style that you want to apply

hourRange.FormatStyle.BackColor = Color.Red



'Add the ScheduleHourRange to the WorkingHourSchema of the Schedule

Me.Schedule1.WorkingHourSchema.WorkingHoursRange.Add(hourRange)

In C#


WorkingHourRecurrencePattern recurrencePattern = new WorkingHourRecurrencePattern();

//Call the BeginEdit before changing the properties of the RecurrencePattern

recurrencePattern.BeginEdit();



//Specify the recurrence pattern. In this case the 10th of every month is the date that //will be formatted

recurrencePattern.SetDefaultValuesForDate(DateTime.Today);

recurrencePattern.PatternStartDate = DateTime.Today;

recurrencePattern.RecurrenceEndMode = RecurrenceEndMode.NoEndDate;

recurrencePattern.RecurrenceType = RecurrenceType.Monthly;

recurrencePattern.StartTime = new TimeSpan(8, 0, 0);

recurrencePattern.EndTime = new TimeSpan(10, 0, 0);

recurrencePattern.DayOfMonth = 10;



recurrencePattern.EndEdit();



//Create the new ScheduleHourRange that will be added to the WorkingHourSchema

ScheduleHourRange hourRange = new ScheduleHourRange();



//Set the RecurrencePattern that will be used

hourRange.RecurrencePattern = recurrencePattern;



//Set the format style that you want to apply

hourRange.FormatStyle.BackColor = Color.Red;



//Add the ScheduleHourRange to the WorkingHourSchema of the Schedule

this.Schedule1.WorkingHourSchema.WorkingHoursRange.Add(hourRange);

If you want to modify only the rows of a particular owner then use the WorkingHourSchema property of the ScheduleAppointment owner to add the ScheduleHourRange

In VB:


Dim owner As ScheduleAppointmentOwner = Me.Schedule1.Owners(0)

owner.WorkingHourSchema.WorkingHoursRange.Add(hourRange)

In C#


ScheduleAppointmentOwner owner = this.Schedule1.Owners[0];

owner.WorkingHourSchema.WorkingHoursRange.Add(hourRange);

Source Of Information : Janus v3.5 Help Files for VS 2008

Using a layout file to preserve user changes [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-13T01:02:00.000+08:00

This tutorial is intended to show you how to use a layout file to preserve Schedule control settings. Using a layout file you could be able to preserve even the changes to the layout made by the user.

Follow these steps to use a layout file at run time:

1) Define the layout at design time and then save it clicking in the "Save Layout File" button that is found in the "Layout Manager" tab of the Schedule control designer.

2) In the Load event of the form, load the layout from a file using the LoadLayoutFile method of the Schedule.

In VB:


   Private Sub LoadLayout()

       Dim layoutDir As String = "C:\ScheduleLayout.xml"

       Dim layoutStream As FileStream = New FileStream(layoutDir, FileMode.Open)

       Schedule1.LoadLayoutFile(layoutStream)

       layoutStream.Close()

   End Sub

In C#:


   private void LoadLayout()

   {

      string layoutDir = @"C:\ScheduleLayout.xml";

      FileStream layoutStream;

      FileInfo fInfo = new FileInfo(layoutDir);

      if (fInfo.Exists)

      {

          layoutStream = new FileStream(layoutDir, FileMode.Open);

          schedule1.LoadLayoutFile(layoutStream);

          layoutStream.Close();

      }

   }

3) (Optional) To preserve user changes to the layout, update the layout before it is changed in the CurrentLayoutChanging event of the Schedule.

In VB:


   Private Sub Schedule1_CurrentLayoutChanging(ByVal sender As System.Object, ByVal e As System.ComponentModel.CancelEventArgs) Handles Schedule1.CurrentLayoutChanging

       'To persist user changes in the current layout,

       'call the Update method explicitly before changing the layout

       If Not Schedule1.CurrentLayout Is Nothing Then

           Schedule1.CurrentLayout.Update()

       End If

   End Sub

In C#:


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

   {

       //To persist user changes in the current layout,

       //call the Update method explicitly before changing the layout

       if (schedule1.CurrentLayout != null)

       {

           schedule1.CurrentLayout.Update();

       }

    }

4) In the Closing event of the form, save the layout file again to be able to preserve the changes the user did (like view, format settings, dates, etc).

In VB:


Private Sub Form1_FormClosing(ByVal sender As System.Object, ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles MyBase.FormClosing

   Dim Result As DialogResult

   Dim LayoutDir As String

   Dim LayoutStream As FileStream



   Result = MessageBox.Show("Do you want to preserve the changes in the Schedule control layout?", "Preserve changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question)

   If Result = Windows.Forms.DialogResult.Cancel Then

       e.Cancel = True

   ElseIf Result = Windows.Forms.DialogResult.Yes Then

       LayoutDir = "C:\ScheduleLayout.xml"

       LayoutStream = New FileStream(LayoutDir, FileMode.Open)

       Schedule1.SaveLayoutFile(LayoutStream)

       LayoutStream.Close()

   End If

End Sub

In C#:


private void Form1_FormClosing(object sender, FormClosingEventArgs e)

{   



    DialogResult result;

    string layoutDir;

    FileStream layoutStream;



    result = MessageBox.Show("Do you want to preserve the changes in the Schedule control layout?", "Preserve changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);



     if (result == DialogResult.Cancel)

     {

         e.Cancel = true;

     }

     else if (result == DialogResult.Yes)

     {

         layoutDir = + @"C:\ScheduleLayout.xml";

         layoutStream = new FileStream(layoutDir, FileMode.Open);

         schedule1.SaveLayoutFile(layoutStream);

         layoutStream.Close();

      }

  }

5) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using multiple layouts [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-12T01:54:00.000+08:00

This tutorial is intended to show you how to use multiple layouts in a Schedule control.

Follow these steps to create multiple layouts at design time:

1) Create a new Visual Basic or C# project using "Windows Application" Template

2) Add a Schedule control to Form1.

3) In the Designer window of the Schedule control, modify the layout as you want, changing the view, dates, owner, etc.

4) Select the "Layout Manager" Tab. A List View will appear with a "Draft Layout" in it. The Draft Layout contains the changes you just made to the Schedule but it is not saved as a layout in the Layouts collection.

5) Click on "Save Current Layout" button and set the name "MonthView" to the draft layout.

6) Once the "MonthView" layout has been saved, add a new layout for products. To add a new layout click on the "New Layout" button and Layout1 will appear.

7) Change the name of Layout1 for "WeekView".

8) Double click in the "WeekView" layout to select this empty layout. This action will set the "WeekView" layout you just created as the CurrentLayout in the Schedule control and all the changes you do will affect this layout only.

9) Change any properties in the new layout like view or owners.

10) Select "Layout Manager" Tab again.

11) Click in the "New Layout" button and Layout1 will appear.

12) Change the name of Layout1 for "WorkWeek".

13) Double click in the "WorkWeek" layout to select this empty layout. This action will set the "WorkWeek" layout you just created as the CurrentLayout in the Schedule control and all the changes you do will affect this layout only.

14) Change any properties in the new layout like view or owners.

15) You have finished adding layouts for the tutorial. To change a property in any of the layouts you have in the Layouts collection, select the layout from Layouts combo in the tool bar of the Schedule designer.

16) To select a layout at run time use the CurrentLayout property of the Schedule class. In the tutorial we are going to do that using buttons. So, add a button "Button1" and

change its Text property to "Show MonthView". In the Click event for this button write the following code that set the "MonthView" layout as the current layout in the Schedule control:

In VB:


If Schedule1.CurrentLayout Is Nothing OrElse Schedule1.CurrentLayout.Key <> "MonthView" Then

    Schedule1.CurrentLayout = Schedule1.Layouts("MonthView")

End If

In C#


if (schedule1.CurrentLayout==null || schedule1.CurrentLayout.Key!="MonthView")

{

  schedule1.CurrentLayout = schedule1.Layouts["MonthView"];

}

17) Add a buttons to show "WeekView" and "WorkWeek" layouts with similar code in the Click event for those buttons.

18) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Saving and Loading Appointments from a stream [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-11T00:46:00.000+08:00

This tutorial is intended to show you how to save and load the Appointments, Fields and Owners collections from a stream.

The steps followed to create this project were:

1) Create a new Visual Basic or C# project using "Windows Application" Template

2) Add a Schedule control to Form1.

3) Add a Calendar control and bind it to the Schedule control.

4) Add a button and change its Text property to "Save"

5) In the Click event of the save button use the SaveAppointments method to save the appointments to a file.

In C#


     this.Cursor = Cursors.WaitCursor;

     string appointmentsDir = @"C:\Appointments.xml";

     System.IO.FileStream appointmentsStream;

     appointmentsStream = new System.IO.FileStream(appointmentsDir, System.IO.FileMode.Create);

     schedule1.SaveAppointments(appointmentsStream);

     appointmentsStream.Close();

     this.Cursor = Cursors.Default;

In VB


     Me.Cursor = Cursors.WaitCursor

     Dim appointmentsDir As String = "C:\Appointments.xml"

     Dim appointmentsStream As System.IO.FileStream

     appointmentsStream = New System.IO.FileStream(appointmentsDir, System.IO.FileMode.Create)

     Schedule1.SaveAppointments(appointmentsStream)

     appointmentsStream.Close()

     Me.Cursor = Cursors.Default

6) Add a button and change its Text property to "Load"

7) In the Click event of the load button, use the LoadAppointments method of the Schedule to load the appointment from a file

In VB


       Me.Cursor = Cursors.WaitCursor

       Dim AppointmentsDir As String = "C:\Appointments.xml"

       Dim AppointmentsStream As System.IO.FileStream

       AppointmentsStream = New System.IO.FileStream(AppointmentsDir, System.IO.FileMode.Open)

       Schedule1.LoadAppointments(AppointmentsStream)

       AppointmentsStream.Close()

       Me.Cursor = Cursors.Default

In C#


           this.Cursor = Cursors.WaitCursor;

           string appointmentsDir = @"C:\Appointments.xml";

           System.IO.FileStream appointmentsStream;

           appointmentsStream = new System.IO.FileStream(appointmentsDir, System.IO.FileMode.Open);

           schedule1.LoadAppointments(appointmentsStream);

           appointmentsStream.Close();

           this.Cursor = Cursors.Default;

8) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Working with Multiple Appointment Owners in a Schedule control [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-10T01:42:00.000+08:00

This tutorial is intended to show how to handle appointments for more than one person.

1) Create a new "Windows Application" Project.

2) Drag a Schedule control from the toolbox into the Form designer.

3) Select the Schedule control in the Form and set the MultiOwner property to true in the properties window.

4) Right click in the Schedule control and select "Schedule Designer" menu. In the Schedule Designer dialog select Owners node.

5) In the Owners panel, Click Add button to add a new owner. Select the new owner and set the following properties in the properties window.

Text = John Doe

Value = Doe

6) Add another owner with the following properties values.

Text = Peter Barker

Value = Barker

Note: In design time the Value property of the ScheduleAppointmentOwner can only be a string. Set the Value in code if you want a different type.

7) In code create two appointments and add them to the Schedule control.

In C#


DateTime startDate = this.schedule1.Date.AddHours(8);



ScheduleAppointment app1 = new ScheduleAppointment(startDate, startDate.AddMinutes(30), "Phone Call");

ScheduleAppointment app2 = new ScheduleAppointment(startDate, startDate.AddMinutes(30), "Go to the dentist");



//The Owner property of the Appointment must be equal to the Value property of //one of the AppointmentOwners in the Schedule control.

app1.Owner = "Doe";

app2.Owner = "Barker";



this .schedule1.Appointments.Add(app1);

this .schedule1.Appointments.Add(app2);

In VB


Dim startDate As DateTime = Me.Schedule1.Date.AddHours(8)



Dim app1 As ScheduleAppointment = New ScheduleAppointment(startDate, startDate.AddMinutes(30), "Phone Call")

Dim app2 As ScheduleAppointment = New ScheduleAppointment(startDate, startDate.AddMinutes(30), "Go to the dentist")



'The Owner property of the Appointment must be equal to the Value property of

'one of the AppointmentOwners in the Schedule control.

app1.Owner = "Doe"

app2.Owner = "Barker"



Me.Schedule1.Appointments.Add(app1)

Me.Schedule1.Appointments.Add(app2)

8) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using SchedulePrintDocument to Print the Control [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-09T01:40:00.000+08:00

The SchedulePrintDocument component allows the developer to print the contents of a Schedule control. In this tutorial, we use a SchedulePrintDocument to provide the application with Print Preview capabilities.

The steps followed to create this project were:

1) Open Form1 in Design mode

2) Drag a Schedule control from the Toolbox into the Form designer

3) Drag a SchedulePrintDocument component from the Toolbox and drop it over Form1

4) Select SchedulePrintDocument1 component in the Components tray and set the Schedule property equal to schedule1

5) Drag a PrintPreviewDialog component from the Toolbox and drop it over Form1

6) Set the Document property of PrintPreviewDialog1 equal to SchedulePrintDocument1

7) Add a button and change its Text property to "Print Preview..."

8) In the Click event of the button, call The ShowDialog method of the PrintPreviewDialog1 component.

9) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Schedule and Calendar controls working together [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-08T01:38:00.000+08:00

This tutorial is intended to show you how to use a Calendar control as the date navigator for a Schedule control bound to it.

Follow these steps to reproduce this sample:

1) Create a new Visual Basic or C# project using "Windows Application" Template

2) Add a Schedule Control to a tab in the Toolbox window by right clicking in the Toolbox window and choosing "Choose Items..." menu. When the dialog appears, select ".Net Framework Components" tab, check "Schedule" control in the list and click OK.

Note: If the Schedule control doesn't appear as an option in the list, click the Browse button and open Janus.Windows.Schedule.dll.

3) Drag a Schedule control from the toolbox into the Form designer.

4) Add a Calendar Control to a tab in the Toolbox window by right clicking in the Toolbox window and choosing "Choose Items..." menu. When the dialog appears, select ".Net Framework Components" tab, check "Calendar" control in the list and click OK.

Note: If the Calendar control doesn't appear as an option in the list, click the Browse button and open Janus.Windows.Schedule.v3.dll.

5) Drag a Calendar control from the toolbox into the Form designer.

6) Select the Calendar control and set the following properties in the properties window:


      Schedule = schedule1

      SelectionStyle = Schedule

7) Set the AllowDrop property of the Calendar control to true in order to allow the user to drop appointments from the Schedule to any date in the Calendar.

Source Of Information : Janus v3.5 Help Files for VS 2008

Binding the Schedule Control to a DataSource [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-07T01:35:00.001+08:00

This tutorial is intended to show you how to bind the Schedule control to a DataSource available at design time.

Follow these steps to create a simple form using a Schedule control to display records from a table in a database.

1) Create a new Visual Basic or C# project using "Windows Application" Template

2) Add a new Data Source to the application:

Click in the "Add New Data Source..." menu under "Data" and follow the wizard to add "Appointments" table from Schedule.mdb database.

In the tutorial we used Provider = "Microsoft Access Database File (OLE DB)" and Database file name = "C:\Schedule.mdb".

3) Build the project to be able to see ScheduleDataSet and AppointmentsTableAdapter as components in the Toolbox.

4) Drag from the tool box ScheduleDataSet and AppointmentsTableAdapter components to the designer.

Now that the DataSet has been created, we can start using the TimeLine control in the project.

5) Add a Schedule Control to a tab in the Toolbox window by right clicking in the Toolbox window and choosing "Choose Items..." menu. When the dialog appears check "Schedule" control in the list and click OK.

Note: If Schedule control doesn't appear as an option in the list, click the Browse button and open Janus.Windows.Schedule.dll.

6) Drag a Schedule control from the toolbox into the Form designer.

7) Select the Schedule control in the Form and set the following properties in the properties window:


          DataSource = scheduleDataSet1

          DataMember = Appointments

          StartTimeMember = StartDate

          EndTimeMember = EndDate

          TextMember = Subject

8) (Optional) Right click on the Schedule control and select "Retrieve Fields" menu. This action will force the control to read the data source structure and create the fields for the items in the table.

9) In the Load event of the Form fill the Appointments table in the dataset with the following code:

In VB.Net


                              Me.AppointmentsTableAdapter1.Fill(Me.ScheduleDataSet1.Appointments)

In C#.Net


                              this.appointmentsTableAdapter1.Fill(this.scheduleDataSet1.Appointments)

10) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using a layout file to preserve user changes [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-06T00:31:00.000+08:00

This tutorial is intended to show you how to save and load a layout file to preserve ExplorerBar
control settings.

Using a layout file you could be able to preserve even the changes to the layout
made by the user.

The steps followed to create this project were:

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Add a ExplorerBar control to Form1.

3) Add a button and change its Text property to "Load".

4) In the Click event of the load button, load the layout from a file calling a procedure similar to
the following:

In VB:


   Private Sub LoadLayout()
       Dim LayoutDir As String = GetLayoutDirectory() + "\ExplorerBarLayout.ebl"
       Dim LayoutStream As FileStream
       LayoutStream = New FileStream(LayoutDir, FileMode.Open)
       ExplorerBar1.LoadLayoutFile(LayoutStream)
       LayoutStream.Close()
   End Sub

In C#:


   private void LoadLayout()
   {
       string layoutDir = GetLayoutDirectory() + @"\ExplorerBarLayout.ebl";
       FileStream layoutStream;
       layoutStream = new FileStream(layoutDir, FileMode.Open);
       explorerBar1.LoadLayoutFile(layoutStream);
       layoutStream.Close();
   }

5) Add a button and change its Text property to "Save".

6) In the Click event of the save button, save the layout from to file calling a procedure similar to
the following:

In VB:


   Private Sub SaveLayout()
       Dim LayoutDir As String = GetLayoutDirectory() + "\ExplorerBarLayout.ebl"
       Dim LayoutStream As FileStream
       LayoutStream = New FileStream(LayoutDir, FileMode.Create)
       ExplorernBar1.SaveLayoutFile(LayoutStream)
       LayoutStream.Close()
   End Sub

In C#:


   private void SaveLayout()
   {
       string layoutDir = GetLayoutDirectory() + @"\ExplorerBarLayout.bbl";
       FileStream layoutStream;
       layoutStream = new FileStream(layoutDir, FileMode.Create);
       explorerBar1.SaveLayoutFile(layoutStream);
       layoutStream.Close();
   }

Note: You can also save the current layout by calling the Update method of the Layout.

In VB:


       If Not ExplorerBar1.CurrentLayout Is Nothing Then
           ExplorerBar1.CurrentLayout.Update()
       End If

In C#:


       if(explorerBar1.CurrentLayout!=null)
       {
           explorerBar1.CurrentLayout.Update();
       }

7) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using a ExplorerBarGroup as a Container Control [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-05T01:53:00.000+08:00

This tutorial is intended to show you how to set an ExplorerBarGroup as a container control.

The steps followed to create this project are:

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Drag an ExplorerBar control from the toolbox into the Form designer.

3) Right click in the ExplorerBar control and select "ExplorerBar Designer" menu. In the
ExplorerBar dialog add a new group and set its Container property to true in the property
window.

4) In the Load event of the form add the TreeView control as follows:

In C#


private void Form1_Load(object sender, System.EventArgs e)
{   
       this.explorerBar1.Groups[0].ContainerControl.Controls.Add(this.treeView1);
this.treeView1.Dock = DockStyle.Fill;
}

In VB


Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles _
MyBase.Load
       Me.ExplorerBar1.Groups(0).ContainerControl.Controls.Add(Me.TreeView1)
       Me.TreeView1.Dock = DockStyle.Fill
End Sub

Note: At design time you can just drag the TreeView control into the ExplorerBarGroup directly

5) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Show ExplorerBar Groups in several columns [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-04T19:50:00.000+08:00

This tutorial is intended to show you how to set ExplorerBar groups in several columns.

The steps followed to create this project are:

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Drag an ExplorerBar control from the toolbox into the Form designer.

3) Select the ExplorerBar control and change the Columns property to 3 in the property
window.

4) Right click in the ExplorerBar control and select "ExplorerBar Designer" menu. Add new
groups and items to the ExplorerBar control in the Designer.

Note: You can specify the column span of each group with the ColumnSpan property of the
ExplorerBarGroup.

5) Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using GridEX in SelfReferencing HierarchicalMode [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-03T01:07:00.000+08:00

This tutorial is intended to show you how to use GridEX to display a self-referencing table in a tree fashion.

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Add a new Data Source to the application:

Click in the "Add New Data Source..." menu under "Data" and follow the wizard to add "Messages" table from GridEXTutorialsData.mdb database.

In the tutorial we used Provider = "Microsoft Access Database File (OLE DB)" and Database file name = "C:\GridEXTutorialsData.mdb".

3) Build the project to be able to see GridEXTutorialsDataDataSet and MessagesTableAdapter as components in the Toolbox.

4) Drag from the tool box GridEXTutorialsDataDataSet component and MessagesTableAdapter component.

5) Drag a GridEX control from the toolbox into the Form designer.

6) Select GridEX control in the Form and set the following properties in the properties window:


           DataSource = GridEXTutorialsDataDataSet1

           DataMember = Messages

7) Right click in the GridEX control and select "Retrieve Structure" menu to create the columns matching those found in the DataSource.

8) Right click in the GridEX control and select "Designer" menu. In the Designer dialog, under RootTable node select Columns node and move the columns positions as you want using Move Up and Move Down toolbar buttons. In the sample, the following properties were changed in the columns:

Column
Property
New Value

MessageID
Visible
False

ParentMessageID
Visible
False

Subject
ColumnType
ImageAndText

ImageIndex
0*

*To be able to set ImageIndex, an ImageList was added to the form and assigned as the ImageList property of the GridEX control

** Selectable property is set as False in all columns.

9) In the designer, now select SelfReferencingSettings node under RootTable and click in the "SelfReferencing Wizard" button that appears at the right side. The settings we used in the wizard are:

HierarchicalMode
SelfReferencing
To present Tree-like hierarchies in a GridEX control.

ParentDataMember
MessageID
The field that identifies the parent column in the self-referencing relation.

ChildDataMember
ParentMessageID
The field that identifies the child column in the self-referencing relation.

ExpandColumn
Subject
The column in the table where the expand glyph will be displayed.

10) In the Load event of the Form fill the "Messages" table in the dataset with the following code:

In VB .Net


                       MessagesTableAdapter1.Fill(GridEXTutorialsDataDataSet1.Messages)

In C#.Net


                       messagesTableAdapter1.Fill(gridEXTutorialsDataDataSet1.Messages);

11) To create a new MessageDataRow in the application, MessageDialog form was added to the project. The form consists of 3 EditBox controls that let the user enter the Subject, the name of the user creating the message and a Message body. This form is called by the method CreateMessage in Form1 as follows:


   private void CreateMessage(object parentId,string subject)

   {

       MessageDialog message = new MessageDialog();

       message.Subject = subject;

       if (message.ShowDialog() == DialogResult.OK)

       {

          //Add a new message row to the dataset

          GridEXTutorialsDataDataSet.MessagesRow newMessage;



          newMessage = gridEXTutorialsDataDataSet1.Messages.NewMessagesRow();

          newMessage.Subject = message.Subject;

          if (message.From.Length == 0)

          {

             newMessage.From = "ANONIMOUS";

          }

          else

          {

             newMessage.From = message.From;

          }

          newMessage.Message = message.Message;

          newMessage.Date = DateTime.Now;

          if (parentId != null)

          {

              newMessage.ParentMessageID = (int)parentId;

          }

          //Add the row to the dataset and it will be displayed

          //automatically in the grid.

          gridEXTutorialsDataDataSet1.Messages.Rows.Add(newMessage);

          //Select the new row in grid

          gridEX1.MoveTo(gridEX1.GetRow(newMessage));

          gridEX1.Focus();
        }

 }

12) Finally, add 3 buttons to the form:


btnNewMessage    (Text = "New Message...")



    In the Click event, a new message with no parent is created as follows:

  

     CreateMessage(null, "New Message");



btnReplyMessage  (Text = "Reply Message...")



    In the Click event, a message with the selected row id as parent is created as follows:





     if (gridEX1.CurrentRow != null &&

         gridEX1.CurrentRow.RowType == RowType.Record)

     {

        CreateMessage(gridEX1.GetValue("MessageID"), "RE: " + gridEX1.GetValue("Subject"));

     }

     else

     {

         MessageBox.Show("Select the message to reply." , "",MessageBoxButtons.OK,MessageBoxIcon.Exclamation);

 }

  

btnDelete              (Text = "Delete Message")



  In the Click event, the selected message is deleted as follows:



    if (gridEX1.CurrentRow != null &&

        gridEX1.CurrentRow.RowType == RowType.Record)

    {

        gridEX1.Delete();

    }

    else

    {

        MessageBox.Show("Select the message you want to delete", "", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);

}

13) Other properties set in the GridEX control are:


AllowEdit = False

AllowDelete = True             To be able to use GridEX.Delete method

HideSelection = Highlight     To see the selected row even when grid is not focused.

14) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using GridEX Control in Unbound Mode [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-02T01:01:00.000+08:00

This tutorial is intended to show you how to use GridEX control in unbound mode using AddItem method to add rows to the control.

Follow these steps to create a simple form using a GridEX control to display unbound items.

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Open Form1 that was created when the project was created.

3) Drop a GridEX control into Form1.

4) Set BoundMode property in GridEX equal to BoundMode.Unbound

5) Open GridEX Designer. Click in the "Create Root Table" button.

6) Add columns to the RootTable.

To create the columns, follow these steps:

6.1 - In the GridEX Designer, select Columns collection below the RootTable node and click in the Add button.

6.2 - Select "Unbound Column" and change the Key of the new column to "Name". Click Next, then Click Finish.

6.3 - Click Add Button Again. In the "Add Column Wizard", Select "Unbound Column" and change the key of the new Column to "Date". Click Next.

6.4 - Change EditType property to CalendarCombo. Click Finish.

6.5 - Once the "Date" column is add, select the column in the designer and change the following properties:


  DataTypeCode = DateTime

  FormatString = d

  DefaultGroupInterval = Date

7) Add a button to the form. Set its Text = "Add Item". In the click event of the button, use the following code:

In VB .NET:

In C# .NET:


    //Add a new row at the end of the list specifying its cell values.

    GridEXRow newRow = this.gridEX1.AddItem();

    //To edit values in cells of a row, call BeginEdit/EndEdit methods

    newRow.BeginEdit();

    newRow.Cells["Name"].Value = "InsertItem";

    newRow.Cells["Date"].Value = DateTime.Now;

    newRow.EndEdit();

    //Move to the new item

   this.gridEX1.MoveTo(newRow);

8) Add another button. Set its Text = "Insert Item". In the click event of the button, use the following code:

In VB .NET:

In C# .NET:


    //Insert the item at the beginning of the list.

    GridEXRow newRow = this.gridEX1.AddItem(0);

    //To edit values in cells of a row, call BeginEdit/EndEdit methods

    newRow.BeginEdit();

    newRow.Cells["Name"].Value = "InsertItem";

    newRow.Cells["Date"].Value = DateTime.Now;

    newRow.EndEdit();

    //Move to the new item

    gridEX1.MoveTo(newRow);

9) Add another button. Set its Text = "Remove Selected Item". In the click event of the button, use the following code:

In VB .NET:

In C# .NET:


     //Get current row

     GridEXRow item = gridEX1.CurrentRow;

     If (item != null && item.RowType == RowType.Record)

     {
         //Delete the row.

         item.Delete();
     }

     else

     {
         MessageBox.Show("Select an item to delete.");
     }

10) Add another button. Set its Text = "Clear Items". In the click event of the button, use the following code:

In VB .NET:

In C# .NET:


     //Clear all items in GridEX

     this.gridEX1.ClearItems();

11) In the Load event of the form, add some rows to the grid.

In VB .NET:

In C# .NET:


     this.gridEX1.AddItem("Item 1", DateTime.Now);

     this.gridEX1.AddItem("Item 2", DateTime.Now);

     this.gridEX1.AddItem("Item 3", DateTime.Now);

     this.gridEX1.AddItem("Item 4", DateTime.Now);

     this.gridEX1.AddItem("Item 5", DateTime.Now);

     this.gridEX1.Row = 0;

12) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using GridEX Control as a Checked List [Janus GridEX WinForms Control v3.5 for .NET]

2010-08-01T01:18:00.000+08:00

This tutorial is intended to show you how to use GridEX control as a checked list control with a column acting as selector and the use of the GetCheckedRows method to retrieve an array containing the GridEXRow objects that are checked.

Follow these steps to create a simple form using a GridEX control as a checked list.

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Drop a GridEX control into Form1.

3) In the GridEX Designer dialog, select the GridEX control node and click in the "Create Root Table" button.

4) Select the Columns node under RootTable node and start the columns the control will present. In this tutorial we created 4 columns. The columns we created and the properties are listed below:

4.1) From:

Add Column Wizard:


           Step 1:

                       "Selector Column"

                       UseHeaderSelector = True

4.2) Icon:


           Add Column Wizard:



  Step 1:

   "Unbound Column"

   BoundMode: UnboundFetch

   Key = "Icon"



  Step 2:

   Caption  = ""

   ColumnType = Image

   EditType = NoEdit



  After finishing the wizard, set these properties:



   AllowSize = False

   ImageIndex = 0

   Selectable = False

   Width = 20

4.3) From:


  Add Column Wizard:



             Step 1:

    "Bound Column"

    DataMember = "From"

                     

                       Step 2:

    Caption  = "From"

    ColumnType = Text

    EditType = NoEdit

                                 

                       After finishing the wizard, set these properties:
                  
                        Selectable = False

4.4) Subject:


  Add Column Wizard:



             Step 1:

    "Bound Column"

    DataMember = "Subject"

                     

                       Step 2:

    Caption  = "Subject"

    ColumnType = Text

    EditType = NoEdit

                                 

                       After finishing the wizard, set these properties:

                        Selectable = False

4.5) Date:


  Add Column Wizard:



             Step 1:

    "Bound Column"

    DataMember = "Date"

                     

                       Step 2:

    Caption  = "Date"

    ColumnType = Text

    EditType = NoEdit

                                 

                       After finishing the wizard, set these properties:

          Selectable = False

5) In the Load event of the Form, Call the BindGridEXControl procedure that creates the dataset and binds the control to it:

In VB .Net:


   Private Sub BindGridEXControl()

       Dim ds As New DataSet()

       Dim table As New DataTable("Messages")

       table.Columns.Add(New DataColumn("From", Type.GetType("System.String")))

       table.Columns.Add(New DataColumn("Subject", Type.GetType("System.String")))

       table.Columns.Add(New DataColumn("Date", Type.GetType("System.DateTime")))

       ds.Tables.Add(table)

       table.Rows.Add(New Object() {"john@mail.com", "Greetings", New DateTime(2002, 2, 5)})

       table.Rows.Add(New Object() {"jenny@mail.com", "Invitation", New DateTime(2002, 2, 7)})

       table.Rows.Add(New Object() {"chris@mail.com", "A question", New DateTime(2002, 2, 10)})

       table.Rows.Add(New Object() {"ana@mail.com",  "How are you?", New DateTime(2002, 2, 12)})

       table.Rows.Add(New Object() {"katherine@mail.com", "Greetings", New DateTime(2002, 2, 14)})

       table.Rows.Add(New Object() {"bill@mail.com", "Hi", New DateTime(2002, 2, 18)})

       table.Rows.Add(New Object() {"ronald@mail.com", "No Subject", New DateTime(2002, 2, 20)})

       Me.GridEX1.SetDataBinding(ds, "Messages")

End Sub

In C# .Net:


private void BindGridEXControl()
{
 DataSet ds = new DataSet();

 DataTable table = new DataTable("Messages");

 table.Columns.Add(new DataColumn("From", typeof(string)));

 table.Columns.Add(new DataColumn("Subject", typeof(string)));

 table.Columns.Add(new DataColumn("Date", typeof(DateTime)));

 ds.Tables.Add(table);

 table.Rows.Add(new Object[] {"john@mail.com", Greetings", new DateTime(2002, 2, 5)});

 table.Rows.Add(new Object[] {"jenny@mail.com", "Invitation", new DateTime(2002, 2, 7)});

 table.Rows.Add(new Object[] {"chris@mail.com", "A question", new DateTime(2002, 2, 10)});

 table.Rows.Add(new Object[] {"ana@mail.com", "How are you?", new DateTime(2002, 2, 12)});

 table.Rows.Add(new Object[] {"katherine@mail.com", "Greetings", new DateTime(2002, 2, 14)});

 table.Rows.Add(new Object[] {"bill@mail.com", "Hi", new DateTime(2002, 2, 18)});

 table.Rows.Add(new Object[] {"ronald@mail.com", "No Subject", new DateTime(2002, 2, 20)});

     this.GridEX1.SetDataBinding(ds, "Messages");                

}

6) Add a button to the form and set its Text property to "Delete". In the Click event of the delete button, get an array containing the checked rows and delete them from its table.

In VB .Net:


   Dim checkedRows() As Janus.Windows.GridEX.GridEXRow

   'get an array with all the rows that the user checked.

   checkedRows = Me.GridEX1.GetCheckedRows()

   'if the user didn't check any row, you will get an empty array      

   If checkedRows.Length = 0 Then

       MessageBox.Show("Select at least 1 message to be deleted.")

   Else

       Dim message As String

       message = String.Format("You are about to delete {0} message(s)." _

                   & vbCrLf & "Do you want to continue?", checkedRows.Length)

       If MessageBox.Show(message, "Janus Tutorial", MessageBoxButtons.YesNo) = DialogResult.Yes Then

           Dim row As Janus.Windows.GridEX.GridEXRow

           For Each row In checkedRows
               CType(row.DataRow, DataRowView).Delete()
           Next

       End If

   End If

In C# .Net:


     Janus.Windows.GridEX.GridEXRow[] checkedRows;

           //get an array with all the rows that the user checked.

           checkedRows = this.GridEX1.GetCheckedRows();

           //if the user didn't check any row, you will get an empty array

           if(checkedRows.Length==0)

           {
  MessageBox.Show("Select at least 1 message to be deleted.");
           }

           else

           {
  string message;

  message = String.Format("You are about to delete {0} message(s)." +

     "\n\rDo you want to continue?", checkedRows.Length);

  if(MessageBox.Show(message, "Janus Tutorial", MessageBoxButtons.YesNo) == DialogResult.Yes)

  {

      foreach(Janus.Windows.GridEX.GridEXRow row in checkedRows)

      {

   ((DataRowView)row.DataRow).Delete();

      }

  }

           }

7) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using ColumnSets [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-31T01:21:00.000+08:00

This tutorial is intended to show you how to use column sets to have more that one line of columns to present a record.

1 - Create a new Visual Basic or C# project using "Windows Application" Template

2 - Add a GridEX control to Form1.

3 - Add Employees table from JSNorthwind database as a Data Source for the application. After adding the table, build the application to be able to see EmployeesTableAdapter and JSNorthwindDataSet components in the tool box.

4 - From the "Data Sources" window in the Application, drag Employees table and drop it into the new GridEX control. JSNorthwindDataSet, EmployeesTableAdapter and EmployeesBindingSource components will be created.

5 - In the Designer window of the GridEX control click on the "Retrieve Structure" button to let GridEX control create the root table and the columns matching those found in the data source.

6 - Select the ColumnSets node under the RootTable node in the designer. Once you have selected the ColumnSets collection, click in the "ColumnSet Designer.." button that appears at the right of the designer.

9 - The first thing you need to do when designing a column set layout is to define how many lines of columns a record will have. To do this, set the ColumnSetRowCount property in the table. In this tutorial, the ColumnSetRowCount property was set to 3.

10 - In the ColumnSets Designer, add a ColumnSet clicking in the "Add ColumnSet" button. Once you click in the button an empty column set will appear in the "ColumnSet Layout" panel. In the ColumnSet, set the number of columns you want to have in it.

11 - From the list of columns in the left side of the designer, drag any column and drop it into the one of the empty slots of the ColumnSet. If you want a column to span 2 or more columns, set the ColSpan property of the column. If you want to a column to span 2 or more rows, set the RowSpan property of the column. ColSpan and RowSpan properties can be set only when a column has been added to a ColumnSet.

12 - Keep creating ColumnSets and filling them with columns by dragging a column from the list and dropping it into a columnset cell until you have defined the ColumnSet layout you want.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using Unbound Columns [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-30T01:09:00.000+08:00

This tutorial is intended to show how to use unbound columns in a bound GridEX control.

Follow these steps to create a simple form using a GridEX control to display records from a table in a database with one unbound column whose values are set in the LoadingRow event.

1 - Create a new Visual Basic or C# project using "Windows Application" Template

2 - Add "Order Details" Table from JSNorthwind database as a Data Source for the application. After adding the table, build the application to be able to see Order_DetailsTableAdapter and JSNorthwindDataSet components in the tool box.

3 - Add a GridEX control to Form1.

4 - From the "Data Sources" window in the Application, drag Order_Details table and drop it into the new GridEX control. JSNorthwindDataSet, Order_DetailsTableAdapter and Orders_DetailsBindingSource components will be created.

5 - In the Designer window of the GridEX control click on the "Retrieve Structure" button to let GridEX control create the root table and the columns matching those found in the data source.

6 - Once the base structure is created, modify the layout as you want, changing the column positions, column widths.

7 - To create an unbound column, follow these steps:

8.1 - In the GridEX Designer, select Columns collection below the RootTable node and click in the Add button.

8.2 - Select "Unbound Column" and change the Key of the new column to "Total". Click Next.

8.3 - Select NoEdit in the EditType Combo. Click Finish.

8.4 - Finally, in the FormatString property of the column, set "c" to see the values of the columns formatted as currency values.

9 - The cells under an unbound column are empty by default. To set the value of a cell that belongs to an unbound column, the developer must handle the LoadingRow event and set the value in the GridEXCell object like it is done in the following code:

In VB.Net


                       If e.Row.RowType = RowType.Record Then

                                   e.Row.Cells("Total").Value = totalValue

                       End If

In C#.Net


                       if(e.Row.RowType==RowType.Record)

                       {

                                   e.Row.Cells["Total"].Value = totalValue;

                       }

10 - Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using Image Columns [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-29T01:07:00.000+08:00

This tutorial is intended to show you how to use image columns in a bound GridEX control.

In this tutorial, there are three column showing images. The first image column shows a default image for every cell in the column. In the second image column, the image is set in code depending on values of other cells in the same row and in the third image column the image displayed in the cell is set in a ValueList so it is dependant on the value of the cell.

1 - Create a new Visual Basic or C# project using "Windows Application" Template

2 - Add Products and Categories Tables from JSNorthwind database as a Data Source for the application. After adding the Tables, build the application to be able to see ProductsTableAdapter and CategoriesTableAdapter components in the tool box.

3 - Add a GridEX control to Form1.

4 - From the "Data Sources" window in the Application, drag Products table and drop it into the new GridEX control. JSNorthwindDataSet, ProductsTableAdapter and ProducctsBindingSource components will be created.

5 - In the Designer window of the GridEX control click on the "Retrieve Structure" button to let GridEX control create the root table and the columns matching those found in the data source.

6 - Once the base structure is created, modify the layout as you want, changing the column positions, column widths.

7 - Add an ImageList component to the form and assign it to the GridEX control setting its ExternalImageList property as the ImageList you added to the form. Add the Images you are going to use in the GridEX control. In this tutorial, we added 8 images corresponding to each product category, one image that represents the product and two other images: one to be displayed in products that are on sale and one to displayed in products that are discontinued.

8 - To create a simple image column follow these steps:

8.1 - In the GridEX Designer, select Columns collection below the RootTable node and click in the Add button.

8.2 - Select "Unbound Column" and change the Key of the new column to "Icon". Click Next.

8.3 - Clear the default Caption in the wizard and select Image in the ColumnType combo. Click Finish.

8.4 - Finally, in the ImageIndex or ImageKey property of the column, select the image you want to show in all the cells below that column.

9 - To create an image column that displays an image depending on the value of other cells in the row follow these steps:

9.1 - In the GridEX Designer, select Columns collection below the RootTable node and click in the Add button.

9.2 - Select "Unbound Column" and Change the Key of the new column to "StatusIcon". Click Next.

9.3 -Clear the default Caption in the wizard and set Image in the ColumnType combo. Click Finish.

9.4 - Finally, in the FormattingRow event of the control, write the code that sets the image index for each cell below that column:

In VB .Net:


  Private Sub GridEX1_FormattingRow(ByVal sender As System.Object, _

       ByVal e As RowLoadEventArgs) Handles GridEX1.FormattingRow

       If e.Row.RowType = RowType.Record Then

           If CType(e.Row.Cells("Discontinued").Value, Boolean) Then

               e.Row.Cells("StatusIcon").ImageKey = "discontinued"

           ElseIf CType(e.Row.Cells("OnSale").Value, Boolean) Then

               e.Row.Cells("StatusIcon").ImageKey = "onsale"

           End If

       End If

   End Sub

In C# .Net:


   private void GridEX1_FormattingRow(object sender, RowLoadEventArgs e)

   {

       if (e.Row.RowType == RowType.Record)

       {

           if ((bool)e.Row.Cells["Discontinued"].Value)

           {

               e.Row.Cells["StatusIcon"].ImageKey = "discontinued";

           }

           else if ((bool)e.Row.Cells["OnSale"].Value)

           {

               e.Row.Cells["StatusIcon"].ImageKey = "onsale";

           }

       }

   }

10 - To create an image column that displays an image assigned in a ValueList, follow these steps:

10.1 - In the GridEX Designer, select Columns collection below the RootTable node and, from the list of columns select CategoryID column.

10.2 -Set the ColumnType property of the column to ColumnType.ImageAndText and its EditType property to EditType.DropDownList

10.3 - Finally, in the Load event of the form, fill the ValueList with the categories available and assign one image to each item in the value list:

In VB .Net:


 Dim categories As GridEXColumn

       categories = GridEX1.RootTable.Columns("CategoryID")

       categories.HasValueList = True

       categories.ColumnType = ColumnType.ImageAndText

       categories.EditType = EditType.DropDownList

       Dim ValueList As GridEXValueListItemCollection

       ValueList = categories.ValueList

       Dim row As JSNorthWindDataSet.CategoriesRow

       For Each row In JSNorthWindDataSet.Categories.Rows

           Dim item As GridEXValueListItem

           item = New GridEXValueListItem(row.CategoryID, _

                                       row.CategoryName)

           'set image Key for items

           item.ImageKey = "Cat(" & row.CategoryID & ")"

           ValueList.Add(item)

       Next

In C# .Net:


   GridEXColumn categories = this.gridEX1.RootTable.Columns["CategoryID"];

   //To be able to get the ValueList from a column, its

   //HasValueList property must be true

   categories.HasValueList = true;

   categories.ColumnType = ColumnType.ImageAndText;

   categories.EditType = EditType.DropDownList;

   GridEXValueListItemCollection ValueList = categories.ValueList;



   //Categories table in the dataset was added as

   //the products table was added before

   foreach(NorthWind.CategoriesRow row in this.northWind1.Categories.Rows)

   {

       GridEXValueListItem item;

       item=new GridEXValueListItem(row.CategoryID,row.CategoryName);

       if(row.CategoryID<=8)              {                 //set image index for items 1 - 8                 //images start from 0 in the image list                 item.ImageIndex = row.CategoryID - 1;              }              ValueList.Add(item);      }

15 - Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Binding GridEX Control to an IList [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-28T01:03:00.000+08:00

This tutorial is intended to show you how to bind GridEX control to a collection in your project that supports IList interface.

Note: When binding to an IList, a data bound control can not add records to the list. To let the users add records in a GridEX control bound to a collection you should implement the IBindingList interface in your collection or handle the GetNewRow event to do create the new object in code.

Follow these steps to create a simple form using a GridEX control to display an IList.

1) Create a new Visual Basic or C# project using "Windows Application" Template.

2) Add a new class into the project and name it Person.

3) Add the following properties to the Person class: Title, Name, LastName and Suffix.

4) To create the collection or person objects, add a new class to the project and name it PersonCollection.

5) Inherit the PersonCollection class from System.Collections.CollectionBase class. CollectionBase class implements IList interface.

6) Create the indexer method as well as the Add and Remove methods in the PersonCollection class.

7) Open Form1 that was created when the project was created.

8) Drop a GridEX control into Form1.

9) Add a button, set the Text property of this button to "Fill Collection"

10) In the Click event of Button1 create a new instance of the PersonCollection class add a few Person objects to the collection and bind it to the GridEX control as follows:

In VB .NET:


       'Creating the collection

       people = New PersonCollection()

       people.Add(New Person("Mr.", "John", "Smith", "Sr."))

       people.Add(New Person("Mrs.", "Mary", "Jones", ""))

       people.Add(New Person("Miss", "Sally", "Porter", ""))

       people.Add(New Person("Mr.", "Joseph", "Gold", "Jr."))

       people.Add(New Person("Dr.", "Ian", "Goldsmith", ""))



       'Binding GridEX to the people collection

       gridEX1.SetDataBinding(people, "")

       'Forcing GridEX control to generate the columns needed

       'to display all the properties in the Person class.

       gridEX1.RetrieveStructure()

In C# .NET:


           //Creating the collection

           people = new PersonCollection();

           people.Add(new Person("Mr.","John","Smith","Sr."));

           people.Add(new Person("Mrs.","Mary","Jones",""));

           people.Add(new Person("Miss","Sally","Porter",""));

           people.Add(new Person("Mr.","Joseph","Gold","Jr."));

           people.Add(new Person("Dr.","Ian","Goldsmith",""));



           //Binding GridEX to the people collection

           gridEX1.SetDataBinding(people,"");

           //Forcing GridEX control to generate the columns needed

           //to display all the properties in the Person class.

         gridEX1.RetrieveStructure();

11) To allow add and remove rows from the collection set the following properties:


           AllowAddNew = Janus.Windows.GridEX.TriState.True

           AllowDelete = Janus.Windows.GridEX.TriState.True

12) Since IList doesn't implement an AddNew method to allow the CurrencyManager to add new records you will get an exception when the user tries to add a record in the GridEX control. If you know how to create a new object of the same type the list holds, use the GetNewRow event. This event is raised to let you create a new instance of an object presented by the GridEX control.

In VB .NET:


Private Sub gridEX1_GetNewRow(ByVal sender As Object,ByVal e As GetNewRowEventArgs) Handles gridEX1.GetNewRow

 e.NewRow = New Person()

End Sub

In C# .NET:


private void gridEX1_GetNewRow(object sender, GetNewRowEventArgs e)

{

 e.NewRow = new Person();

}

13) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using Custom Edit Events [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-27T01:58:00.000+08:00

Steps to reproduce this sample:

1) Create a new "Windows Application" Project.

2) Add Customers Table from JSNorthwind database as a Data Source for the application.

3) Add GridEX Control to a tab in the Toolbox window by right clicking in the Toolbox window and choosing "Customize Toolbox..." menu. When the dialog appears, select ".Net Framework Components" tab, check "GridEX" control in the list and click OK.
Note: If GridEX control doesn't appear as an option in the list, click the Browse button and open Janus.Windows.GridEX.dll.

4) Drag a GridEX control from the toolbox into the Form designer.

5) From the "Data Sources" window in the Application, drag Customers and drop it into the new GridEX control. JSNorthwindDataSet, CustomersTableAdapter and CustomersBindingSource components will be created.

5) Right click in the GridEX control and select "Retrieve Structure" menu. This action will force the control to read the DataSource structure and create the tables and columns needed to show all the fields in the tables.

6) Right click in the GridEX control again and select "GridEX Designer" menu. In the GridEX designer dialog, select "Columns" under GridEX/RootTable node.

7) In the right pane, select "CustomerID" column and change the EditType property to Custom. Setting this property, you will be able to get the InitCustomEdit event every time the user tries to edit a cell in this column.

8) Drop a TextBox control into the Form and change its name to txtCustom. This text box will be the one used as the edit window in the CustomerID column.

9) In the InitCustomEdit event of the GridEX control, set the Text property of the TextBox acting as the custom edit control and set the EditControl property of the InitCustomEditEventArgs parameter to the txtCustom control.

In VB .NET


       'For the sample, we will use BackColor Yellow in the TextBox

       'if the cell is in a new row

       If e.Row.RowType = RowType.NewRecord Then

           txtCustom.BackColor = Color.Yellow

       Else

           txtCustom.BackColor = e.FormatStyle.BackColor

       End If



       'When the user start edition by pressing a key,

       'the EditChar property holds the char that

       'started the edition. If edition was started

       'because the user clicked in the cell the

       'EditChar returns (char)0

       If Char.IsLetterOrDigit(e.EditChar) Then

           txtCustom.Text = e.EditChar.ToString()

           txtCustom.SelectionStart = txtCustom.Text.Length

       Else

           If e.Value Is Nothing Then

               txtCustom.Text = ""

           Else

               txtCustom.Text = e.Value.ToString()

           End If

           txtCustom.SelectionLength = txtCustom.Text.Length

       End If

       'Set the EditControl property to let the GridEX control

       'know which control to position in the cell.

       e.EditControl = txtCustom

In C# .NET


           //For the sample, we will allow to edit

    //the CustomerID field only in new rows.

        //So, we set the ReadOnly property to false

           //if rows with RowType set to Record.

           if(e.Row.RowType==RowType.NewRecord)

           {

                       txtCustom.ReadOnly=false;

           }

           else

           {

                       txtCustom.ReadOnly = true;

           }

            //When the user start edition by pressing a key,

     //the EditChar property holds the char that started

     //the edition. If edition was started because the

     //user clicked in the cell the EditChar

           //returns (char)0

           if(e.EditChar!=(char)0 && !txtCustom.ReadOnly)

           {

                       txtCustom.Text = e.EditChar.ToString();

                       txtCustom.SelectionStart = txtCustom.Text.Length;

           }

           else

           {

                       if(e.Value==null)

                       {

                                   txtCustom.Text = "";

                       }

                       else

                       {

                                   txtCustom.Text = e.Value.ToString();

                       }

                       txtCustom.SelectionLength = txtCustom.Text.Length;

           }

           //Set the EditControl property to let the GridEX control

           //know which control to position in the cell.

           e.EditControl = txtCustom;

10) In the EndCustomEdit event of the GridEX control, compare value of the value in the TextBox to the original value in the cell. If the value has changed, set the Value property of the EndCustomEditEventArgs parameter to the new value and set the DataChanged property to true to inform the GridEX control that the cell must be updated in the data source.

In VB .NET


       If Not e.CancelUpdate Then

           If e.Value <> txtCustom.Text Then

               e.Value = txtCustom.Text

           End If

       End If

In C# .NET


 //Compare the original value with

 //the value in the control.

 if(txtCustom.Text.CompareTo(e.Value)!=0)

 {
     //If the value is different,

     //set the DataChanged property to true

     //to indicate the control that it has

     //to update the cell value.

     e.DataChanged = true;

     e.Value = txtCustom.Text;
 }

11) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using a layout file to preserve user changes [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-26T01:53:00.000+08:00

This tutorial is intended to show you how to use a layout file to preserve GridEX control settings. Using a layout file you could be able to preserve the changes to the layout made by the user.

The Layout file used in this tutorial was saved with the GridEX designer using the multiple layouts defined in tutorial 13.

Follow these steps to use a layout file at run time:

1 - Define the layout at design time and then save it clicking in the "Save Layout File" button that is found in the "Layout Manager" tab of the GridEX control designer.

2 - (Optional) Clear all the settings of the GridEX control at run time clicking in the menu "Reset Defaults" that appears when you right click a GridEX control.

3 - In the Load event of the form, load the layout from a file calling a procedure similar to the following:

In VB:


   Private Sub LoadLayout()

       Dim LayoutDir As String = GetLayoutDirectory() + "\GridEXLayout.gxl"

       Dim LayoutStream As FileStream

       LayoutStream = New FileStream(LayoutDir, FileMode.Open)

       GridEX1.LoadLayoutFile(LayoutStream)

       LayoutStream.Close()

   End Sub

In C#:


    private void LoadLayout()

    {

        string layoutDir = GetLayoutDirectory() + @"\GridEXLayout.gxl";

        if (FileExists(layoutDir))

        {

             FileStream layoutStream;

             layoutStream = new FileStream(layoutDir, FileMode.Open);

             GridEX1.LoadLayoutFile(layoutStream);

             layoutStream.Close();

        }

    }

4 - In the CurrentLayoutChanged event, bound the GridEX control to its data source and fill the data source as follows:

In VB:


   Private Sub GridEX1_CurrentLayoutChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles GridEX1.CurrentLayoutChanged

       'clear the DataTable used by the previous layout

       JsNorthWindDataSet1.Clear()

       'when layouts are persisted into a file,

       'the DataSource and DataMember properties are

       'not persisted so you must reset them at run time

       'instead of resetting the DataSource and DataMember

       'properties when the layout is made, this could be done

       'in all the layouts at once in the LayoutLoad event

       If Not GridEX1.CurrentLayout Is Nothing Then

           Select Case GridEX1.CurrentLayout.Key

               Case "Customers"

                   CustomersTableAdapter1.Fill(JsNorthWindDataSet1.Customers)

                   GridEX1.SetDataBinding(JsNorthWindDataSet1, "Customers")

               Case "Products"

                   ProductsTableAdapter1.Fill(JsNorthWindDataSet1.Products)

                   GridEX1.SetDataBinding(JsNorthWindDataSet1, "Products")

               Case "Suppliers"

                   SuppliersTableAdapter1.Fill(JsNorthWindDataSet1.Suppliers)

                   GridEX1.SetDataBinding(JsNorthWindDataSet1, "Suppliers")

           End Select

       End If



   End Sub

In C#:


   private void GridEX1_CurrentLayoutChanged(object sender, EventArgs e)

   {

       //clear the DataTable used by the previous layout

       jsNorthWindDataSet1.Clear();



       //When layouts are persisted into a file,

       //the DataSource and DataMember properties are

       //not persisted so you must reset them at run time

       //instead of resetting the DataSource and DataMember

       //properties when the layout is made, this could be done

       //in all the layouts at once in the LayoutLoad event

       if (GridEX1.CurrentLayout != null)

       {

           switch (GridEX1.CurrentLayout.Key)

           {

               case "Customers":

                  customersTableAdapter1.Fill(jsNorthWindDataSet1.Customers);

                  GridEX1.SetDataBinding(jsNorthWindDataSet1, "Customers");

                  break;

               case "Products":

                  productsTableAdapter1.Fill(jsNorthWindDataSet1.Products);

                  GridEX1.SetDataBinding(jsNorthWindDataSet1, "Products");

                  break;

               case "Suppliers":

                  suppliersTableAdapter1.Fill(jsNorthWindDataSet1.Suppliers);

                  GridEX1.SetDataBinding(jsNorthWindDataSet1, "Suppliers");

                  break;

           }

       }

   }

5- (Optional) To preserve user changes to the layout, update each layout before it is changed in the CurrentLayoutChanging event.

In VB:


   Private Sub GridEX1_CurrentLayoutChanging(ByVal sender As Object, _

       ByVal e As System.ComponentModel.CancelEventArgs) Handles _

       GridEX1.CurrentLayoutChanging

       'to persist user changes in the current layout,

       'call the Update method explicitly before changing the layout

       If Not GridEX1.CurrentLayout Is Nothing Then

           GridEX1.CurrentLayout.Update()

       End If

   End Sub

In C#:


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

   {

       //to persist user changes in the current layout,

       //call the Update method explicitly before changing the layout

       if(gridEX1.CurrentLayout!=null)

       {

           gridEX1.CurrentLayout.Update();

       }

   }

6 - In the Closing event of the form, save the layout file again to be able to preserve the changes the user did (like grouping, sorting, columns size and position etc).

In VB:


   Protected Overrides Sub OnClosing(ByVal e As System.ComponentModel.CancelEventArgs)

        Dim Result As DialogResult

        Dim LayoutDir As String

        Dim LayoutStream As FileStream





        Result = MessageBox.Show("Do you want to preserve the changes in the _

                                 GridEX control layout?", "Preserve changes", _

                                 MessageBoxButtons.YesNoCancel, _

                                 MessageBoxIcon.Question)

       If Result = DialogResult.Cancel Then

           e.Cancel = True

       ElseIf Result = DialogResult.Yes Then

           LayoutDir = GetLayoutDirectory() + "\GridEXLayout.gxl"

           LayoutStream = New FileStream(LayoutDir, FileMode.Create)

           GridEX1.SaveLayoutFile(LayoutStream)

           LayoutStream.Close()

       End If

   End Sub

In C #:


   protected override void OnClosing(CancelEventArgs e)

   {

       base.OnClosing(e);

       DialogResult result;

       string layoutDir;

       FileStream layoutStream;



       result = MessageBox.Show("Do you want to preserve the changes in " +

               "the GridEX control layout?", "Preserve changes",

               MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

       if (result == System.Windows.Forms.DialogResult.Cancel)

       {

           e.Cancel = true;

       }

       else if (result == System.Windows.Forms.DialogResult.Yes)

       {

           DirectoryInfo dInfo;

           dInfo = new DirectoryInfo(Application.ExecutablePath).Parent;

           dInfo = new DirectoryInfo(dInfo.FullName + @"\LayoutData");

           if (!dInfo.Exists) dInfo.Create();

           layoutDir = dInfo.FullName + @"\GridEXLayout.gxl";

           layoutStream = new FileStream(layoutDir, FileMode.Create);

           GridEX1.SaveLayoutFile(layoutStream);

           layoutStream.Close();

       }

   }

7 - Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using multiple layouts [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-25T01:48:00.000+08:00

How to use multiple layouts in a GridEX control.

It is assumed that you are familiarized with the creation of DataSets with multiple tables and changing GridEX control settings at design time

Follow these steps to create multiple layouts at design time:

1 - Create a new Visual Basic or C# project using "Windows Application" Template

2 - Using the JSNorthWind Data Source, select the Customers, Products and Suppliers tables.

3 - Build the application to be able to see JSNorthwindDataSet and the TableAdapters created in the Tool box.

4 - Drag JSNorthwindDataSet and drop it into Form1.

5 - Drag CustomersTableAdapter and drop it into Form1.

6 - Drag ProductsTableAdapter and drop it into Form1.

7 - Drag SuppliersTableAdapter and drop it into Form1.

8 - Add a GridEX control to Form1.

7 - In GridEX control, select JSNorthwindDataSet1 as the DataSource and Customers as the DataMember.

8 - In the Designer window of the GridEX control click on the "Retrieve Structure" button to let GridEX control create the root table and the columns matching those found in the data source.

9 - Once the base structure is created, modify the layout as you want, changing the column positions, column widths, adding an icon column, etc.

9 -Select the "Layout Manager" Tab. A List View will appear with a "Draft Layout" in it. The Draft Layout contains the table structure you just created but it is not saved as a layout in the Layouts collection.

10 - Click on "Save Current Layout" button and set the name "Customers" to the draft layout.

11 -Once the "Customers" layout has been saved, add a new layout for products. To add a new layout click on the "New Layout" button and Layout1 will appear.

12 - Change the name of Layout1 for "Products".

13 - Double click in the "Products" layout to select this empty layout. This action will set the "Products" layout you just created as the CurrentLayout in the GridEX control and all the changes you do will affect this layout only.

14 - In GridEX control properties select JSNorthwindDataSet1 as the DataSource and Products as the DataMember.

15 - Click on "Retrieve Structure" button.

16 - Change any properties in the new layout like column positions or column widths.

17 - Select "Layout Manager" Tab again.

18 - Click in the "New Layout" button and Layout1 will appear.

19 - Change the name of Layout1 for "Suppliers".

20 - Double click in the "Suppliers" layout to select this empty layout. This action will set the "Products" layout you just created as the CurrentLayout in the GridEX control and all the changes you do will affect this layout only.

21 - In GridEX control properties select JSNorthwindDataSet1 as the DataSource and Suppliers as the DataMember

22 - Click on Retrieve Structure button.

23 - Change any properties in the new layout like column positions or column widths.

24 - You have finished adding layouts for the tutorial. To change a property in any of the layouts you have in the Layouts collection, select the layout from Layouts combo in the tool bar of the GridEX designer.

25 - To select a layout at run time use the CurrentLayout property of the GridEX class. In the tutorial we are going to do that using buttons. So, add a button "Button1" and change its Text property to "Show Customers". In the Click event for this button write the following code that set the "Customers" layout as the current layout in the GridEX control:

In VB:


          If GridEX1.CurrentLayout Is Nothing OrElse _

             GridEX1.CurrentLayout.Key <> "Customers" Then

             GridEX1.CurrentLayout = GridEX1.Layouts("Customers")

          End If

In C#


if(gridEX1.CurrentLayout==null || gridEX1.CurrentLayout.Key!="Customers")

{

  gridEX1.CurrentLayout = gridEX1.Layouts["Customers"];

}

26 - Add a buttons to show "Products" and "Suppliers" layouts with similar code in the Click event for those buttons.

27 - Now that we have written code to select the different layouts what rests is to fill the appropriate DataTable when a layout is selected. To do that, we handle the CurrentLayoutChanged event as follows:

In VB:


      'clear the DataTable used by the previous layout

      JsNorthWindDataSet1.Clear()

      If Not GridEX1.CurrentLayout Is Nothing Then

          Select Case GridEX1.CurrentLayout.Key

              Case "Customers"

                  CustomersTableAdapter1.Fill(JsNorthWindDataSet1.Customers)

              Case "Products"

                  ProductsTableAdapter1.Fill(JsNorthWindDataSet1.Products)

              Case "Suppliers"

                  SuppliersTableAdapter1.Fill(JsNorthWindDataSet1.Suppliers)

          End Select

      End If

In C#:


//clear the DataTable used by the previous layout

jsNorthWindDataSet1.Clear();

if (GridEX1.CurrentLayout != null)

{

 switch (GridEX1.CurrentLayout.Key)

 {

    case "Customers":               

       customersTableAdapter1.Fill(jsNorthWindDataSet1.Customers);

       break ;

    case "Products":

       productsTableAdapter1.Fill(jsNorthWindDataSet1.Products);

       break ;

    case "Suppliers":

       suppliersTableAdapter1.Fill(jsNorthWindDataSet1.Suppliers);

       break ;

 }

}

28 - Run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Binding GridEX control at run time [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-24T01:42:00.000+08:00

To bind GridEX control at runtime, instead of using DataSource and DataMember properties you must use SetDataBinding method.

Once the control is bound you must call the RetrieveStructure method in order to force the control to create the table(s) and fields defined in the data source.

In VB:


    'binding control at runtime

    'First, get the table you want to bind to the control and populate it

    'in this sample we create a table in memory but

    'you can also create a table

    'using OleDBConnection and OleDBDataAdapter object



       Dim myTable As DataTable = New DataTable("GridEXTest")



       'creating the columns in the table

       myTable.Columns.Add("Number", GetType(Integer))

       myTable.Columns.Add("Text", GetType(String))

       myTable.Columns.Add("Date", GetType(DateTime))



       'adding rows

       myTable.Rows.Add(1, "Text 1", DateTime.Today)

       myTable.Rows.Add(2, "Text 2", DateTime.Today)

       myTable.Rows.Add(3, "Text 3", DateTime.Today)



       'call SetDataBinding method to bind the control at run time

       'and be able to set DataSource and DataMember properties

       'at the same time

       GridEX1.SetDataBinding(myTable, "")



       'Once the control is bound, call Retrieve Structure method

       'to force the control to create the table(s) and column(s)

       'defined in the DataSource

       GridEX1.RetrieveStructure()

In C#:


//binding control at runtime

//First, get the table you want to bind to the control

//and populate it.

//In this sample we create a table in memory but

//you can also create a table

           //using OleDBConnection and OleDBDataAdapter object

DataTable myTable = new DataTable("GridEXTest");



           //creating the columns in the table

myTable.Columns.Add("Number", typeof(int));

myTable.Columns.Add("Text", typeof(string));

myTable.Columns.Add("Date", typeof(DateTime));



//adding rows

myTable.Rows.Add(1, "Text 1", DateTime.Today);

myTable.Rows.Add(2, "Text 2", DateTime.Today);

myTable.Rows.Add(3, "Text 3", DateTime.Today);



//call SetDataBinding method to bind the control at run time

//and be able to set DataSource and DataMember properties

//at the same time

gridEX1.SetDataBinding(myTable, "");



//Once the control is bound, call Retrieve Structure method

//to force the control to create the table(s) and column(s)

//defined in the DataSource

gridEX1.RetrieveStructure();

Source Of Information : Janus v3.5 Help Files for VS 2008

Displaying Hierarchical Data [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-23T01:39:00.000+08:00

Steps to reproduce this sample:

1) Create a new "Windows Application" Project.

2) Add a new Data Source to the application:

Click in the "Add New Data Source..." menu under "Data" and follow the wizard to add "Customers", "Orders" and "Order Details" tables from JSNorthWind.mdb database.

In the tutorial we used Provider = "Microsoft Access Database File (OLE DB)" and Database file name = "C:\JSNorthWind.mdb".

3) Build the project to be able to see JSNorthwindDataSet, CustomersTableAdapter, OrdersTableAdapter and Order_DetailsTableAdpater as components in the Toolbox.

4) Drag from the tool box JSNorthwindDataSet, CustomersTableAdapter, OrdersTableAdapter and Order_DetailsTableAdpater components.

5) Add GridEX Control to a tab in the Toolbox window by right clicking in the Toolbox window and choosing "Customize Toolbox..." menu. When the dialog appears, select ".Net Framework Components" tab, check "GridEX" control in the list and click OK.
Note: If GridEX control doesn't appear as an option in the list, click the Browse button and open Janus.Windows.GridEX.dll.

6) Drag a GridEX control from the toolbox into the Form designer.

Select GridEX control in the Form and set the following properties in the properties window:

DataSource = JSNorthwindDataSet1
DataMember = "Customers"

7) Right click in the GridEX control and select "Retrieve Hierarchical Structure" menu. This action will force the control to read the DataSource structure and create the tables and columns needed to show all the fields in the tables.

8) In the Load event of the Form fill the tables in the dataset with the following code:

In VB.Net


          CustomersTableAdapter1.Fill(JsNorthWindDataSet1.Customers)

          OrdersTableAdapter1.Fill(JsNorthWindDataSet1.Orders)

          Order_DetailsTableAdapter1.Fill(JsNorthWindDataSet1.Order_Details)

In C#.Net


           customersTableAdapter1.Fill(jsNorthWindDataSet1.Customers);

           ordersTableAdapter1.Fill(jsNorthWindDataSet1.Orders);

           order_DetailsTableAdapter1.Fill(jsNorthWindDataSet1.Order_Details);

9) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Updating Changes to the Database [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-22T01:26:00.000+08:00

Since a DataSet works with disconnected data, you must explicitly commit the changes in the dataset to the data source. This tutorial is intended to show you a simple example of how to do this:

1) Add a button to the Form and Change its Name property to UpdateButton and its Text property to "Update"

2) In the Click event of the UpdateButton, get a table with the rows that has changes, if the table is not empty, call the Update method in the DataAdapter to write those changes into the database.

In VB:


Dim changedRecords As System.Data.DataTable

changedRecords = JSNorthWindDataSet.Products.GetChanges()

If Not (changedRecords Is Nothing) AndAlso _

           (changedRecords.Rows.Count > 0) Then

 Dim message As String

        message = String.Format("You are about to update {0} record(s)." _

            + vbCrLf + "Do you want to continue?", changedRecords.Rows.Count)



        If MessageBox.Show(message, "GridEX Tutorial", MessageBoxButtons.YesNo, _

            MessageBoxIcon.Question) = System.Windows.Forms.DialogResult.Yes Then

           Try

               ProductsTableAdapter.Update(JSNorthWindDataSet.Products)

           Catch exc As Exception

               MessageBox.Show( _

   "An error occurred while trying to update the database:" + _

    vbCrLf + exc.Message + vbCrLf + vbCrLf + _

    "The rows with errors will appear in dark red.", _

    "GridEX Tutorial" , MessageBoxButtons.OK, _

    MessageBoxIcon.Exclamation)

           End Try

        End If

     Else

       MessageBox.Show("There are no changes in the Products table to update.", _

          "GridEX Tutorial", MessageBoxButtons.OK, MessageBoxIcon.Information)

 End If

In C#:


DataTable changedRecords;

changedRecords = jsNorthWindDataSet1.Products.GetChanges();

if (changedRecords != null && changedRecords.Rows.Count > 0)

{

  string message;

  message = String.Format("You are about to update {0} record(s)."

  + "\n\rDo you want to continue?", changedRecords.Rows.Count);

  if (MessageBox.Show(message, "GridEX Tutorial",

        MessageBoxButtons .YesNo,

        MessageBoxIcon .Question) == DialogResult.Yes)

  {

     Try

     {

        productsTableAdapter1.Update(jsNorthWindDataSet1.Products);

     }

     catch (Exception exc)

     {

        MessageBox.Show("An error occurred while trying to update " +

             "the database:\n\r" + exc.Message + "\n\n\r" +

             "The rows with errors will appear in dark red." ,

             "GridEX Tutorial" , MessageBoxButtons.OK,

             MessageBoxIcon .Exclamation);

     }

  }

}

Else

{

  MessageBox.Show("There are no changes in the Products

table to update." , "GridEX Tutorial", MessageBoxButtons.OK, MessageBoxIcon.Information);

}

3) Press F5 and run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using GridEXPrintDocument to Print the Control [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-21T01:23:00.000+08:00

GridEXPrintDocument component allows the developer to print the contents of a GridEX control.

We are going to use a GridEXPrintDocument to provide the application with Print and Print Preview capabilities.

The steps required to create this project are:

1) Open Form1 in Design mode

2) Drag a GridEXPrintDocument component from the Toolbox and drop it over Form1

3) Select GridEXPrintDocument1 component in the Components tray and set its GridEX property equal to GridEX1

4) Drag a PrintPreviewDialog component from the Toolbox and drop it over Form1

5) Set the Document property of PrintPreviewDialog1 equal to GridEXPrintDocument1

6) Add a button and change its Text property to "Print Preview& "

7) In the Click event of the button, call the ShowDialog method of the PrintPreviewDialog1 component.

8) Run the project.

Changing Colors and Fonts using Predefined FormatStyles [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-20T01:21:00.000+08:00

In GridEX control, Predefined FormatStyles are used to specify how the different areas of the control will be drawn.

In each format style you can specify Font, colors, transparency, gradients, etc. that will be used to draw a particular area of the control. Also, the dialog lets you change the properties in the ControlStyle object that will be used to draw internal controls in the grid like scrollbars and buttons.

The PredefinedStyles used in this tutorial are:

RowFormatStyle: Holds the format settings used when drawing rows in the control. When AlternatingColors property is True, this style will be used only in odd rows while AlternatingRowFormatStyle will be used in even rows.

HeaderFormatStyle: Holds the format settings used when drawing column and row headers.

AlternatingRowFormatStyle: Holds the format settings used when drawing even rows when AlternatingColors property if True. This FormatStyle is merged with RowFormatStyle before it is applied.

SelectedFormatStyle: Holds format settings to be used when drawing selected rows. This FormatStyle is merged with the FormatStyle used to draw the row when it is not selected (the base FormatStyle can be Row, AlternatingRow, GroupRow, NewRow, etc)

GroupByBoxFormatStyle: Holds format settings to be used when drawing the group by box background.

GroupByBoxInfoFormatStyle: Holds format settings to be used when drawing the information text in the group by box when no columns are grouped.

GroupRowFormatStyle: Holds format settings to be used when drawing group rows. This FormatStyle is merged with RowFormatStyle before it is applied.

CardCaptionFormatStyle: Holds format settings to be used when drawing the caption bar in cards.

CardColumnHeaderFormatStyle: Holds format settings to be used when drawing column headers in a card. This FormatStyle is merged with RowFormatStyle before it is applied.

Source Of Information : Janus v3.5 Help Files for VS 2008

Changing Control's Appearance [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-19T01:14:00.001+08:00

There are several properties used to define the appearance of the GridEX control.

We are using only a few of these properties to give you a hint of the possibilities the control has when it comes to its appearance.

The properties used in this tutorial are:

In GridEX Control:

ThemedAreas: With this property, you can define whether to use Windows XP Visual Styles to render some areas of the GridEX control like scrollbars or headers.

VisualStyle: With this property, you can define whether to use standard grid style or Office 2003 style to draw the control. Also, VisualStyleAreas property allows you to determine which visual style to use in each of the different areas of the control.

RowHeaders: To determine whether the control will display a row header at the beginning of the row.

GroupByBoxVisible: Hides or shows the Group By Box area in the control.

AlternatingColors: If this property is set to True, GridEX control will render odd rows using RowFormatStyle settings and even rows using AlternatingRowFormatStyle settings. The colors used in these format styles can be changed directly in the GridEXFormatStyle class.

RecordNavigator: Hides or shows the record navigator in the control.

BorderStyle: Determines which style to use when drawing the border of the control.

GridLines: Lets you specify whether the control will draw vertical and or horizontal lines to separate the cells.

GridLineStyle: Determines if the grid lines in the control will be drawn as a solid or dotted line.

Header Appearance: Unlike the previous properties that belong to the GridEX control directly. This property is set in the GridEXFormatStyle instance that is associated to the HeaderFormatStyle property. HeaderFormatStyle determines the appearance of column and row headers.

Grid.HeaderFormatStyle.Appearance = Appearance.Flat

ScrollBar and DropDowns appearance: The appearance of the scrollbars, buttons, dropdown buttons and record navigator is defined in the ControlStyle property. With the ControlStyle instance associated to the control you can specify the 3D appearance of buttons and also their colors.

Source Of Information : Janus v3.5 Help Files for VS 2008

Customizing Card View [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-18T01:03:00.000+08:00

The properties used to enhance Card View used in this tutorial are:

In GridEX Control:


          CardCaptionPrefix = "Product:"

          CardColumnHeaderFormatStyle.FontBold = TriState.True

          CenterSingleCard  = False

In Column objects:


          Column["Icon"]
          CardIcon = True

CardIcon property is used to instruct the control to use the icon displayed in this column as the icon in the card caption. Only one column can have this property equal to True.


     Column["ProductName"]
          CardCaption = True

CardCaption property is used to instruct the control to use the text in this column as the text shown in the card caption. Only one column can have this property equal to True.

After setting these properties, we added a combo box to let the user switch between Table, Card and Single Card Views. When the user selects a view, other properties are also set depending on the selected view. For instance, in card views, we are hiding the Icon column to show it only in the card’s caption but not as a part of the card body. When SingleCardView is selected, the RecordNavigator is shown to let the user navigate through all the records in the products table. Refer to the SelectedIndexChanged event of the Combo Box to see the code.

Source Of Information : Janus v3.5 Help Files for VS 2008

Using Conditional Formatting [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-17T01:41:00.000+08:00

There could be situations where you want to apply different formats to rows or cells depending on a condition. You could use FormatConditions in GridEX control for this effect.

1) A FormatCondition that uses StrikeOut font and gray ForeColor to indicate the user that the product is discontinued.

2) A FormatCondition that uses Bold Font and red ForeColor to indicate the user that the product is on sale.

The steps you need to add a FormatCondition is code are:

1) Create a new GridEXFormatCondition object:

In the following code we are creating a FormatCondition and then defining the FormatStyle settings that will be applied to all the rows where Discontinued column value is True.

In VB:


      Dim fc As GridEXFormatCondition

      fc = New GridEXFormatCondition(GridEX1.RootTable.Columns("Discontinued"), ConditionOperator.Equal, True)

In C#:


                      GridEXFormatCondition fc = new GridEXFormatCondition(this.gridEX1.RootTable.Columns["Discontinued"],ConditionOperator.Equal,true);

2) Specify the FormatStyle properties you want to be applied in the rows where the condition is met.

fc.FormatStyle.FontStrikeout = TriState.True;

fc.FormatStyle.ForeColor = SystemColors.GrayText;

3) Add the FormatCondition created to the FormatCondition collection in the table.

gridEX1.RootTable.FormatConditions.Add(fc);

Source Of Information : Janus v3.5 Help Files for VS 2008

Using MultiColumn DropDowns [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-16T01:35:00.000+08:00

The SupplierID field will have a GridEX dropdown to display the Suppliers' name to the user while the control internally works with the SupplierID value. The GridEXDropDown object is used also as the source list of a dropdown list when MultiColumnCombo or MultiColumnDropDown EditType is used.

To have a MultiColumn DropDown in a column you must:

1 - Add Suppliers table to JSNorthwindDataSet. To add a table to an existing DataSet, in the Data Sources window, click in the "Configure DataSet wizard button and check the table you want to add in the dialog that appears.

2 - Build the application so you can see SuppliersTableAdapter component in the tool box.

3 - Drag SuppliersTableAdapter component from the toolbox and drop it into the form.

4 - In the GridEX Designer dialog:

Select DropDowns node and click Add button

In the MultiColumnConfiguration Wizard, Select JSNorthwindDataSet as DataSource and Suppliers as DataMember

Click Next

Check the column you want to show in the drop down (In this sample we selected SupplierID and CompanyName)

Click Next

Set Key = "Suppliers"

Column = SupplierID

ValueMember = "SupplierID"

DisplayMember = "CompanyName"

Click Finish

5 - In the Columns Node of the GridEX control, select SupplierID Column.

10 - Change the following properties in the column

EditType = MultiColumnCombo

CompareTarget = Text

DefaultGroupInterval = Text

11 - In the Load event of the Form, fill the Suppliers table using this code:

SuppliersTableAdapter.Fill(JSNorthwindDataSet.Suppliers)

12 - Set the DataSource and DataMember properties of the DropDown at run time. DropDown objects cannot keep the DataSource and DataMember properties you have used at design time to retrieve the column layout.

For that reason, you need to reset those properties at runtime.

In the Load event of Form1 write:

In VB:


GridEX1.DropDowns("Suppliers").SetDataBinding(JSNorthwindDataSet,"Suppliers")

In C#:


gridEX1.DropDowns["Suppliers"].SetDataBinding(jsNorthwindDataSet,"Suppliers");

11 - Run the project

Source Of Information : Janus v3.5 Help Files for VS 2008

Using ValueLists [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-15T01:31:00.000+08:00

A column in the GridEX control can have a look up list to replace ID's stored in a table for a name associated to that ID.

The CategoryID field will have a value list to display the Category name to the user while the control internally works with the CategoryID value. The ValueList object is used also as the source list of a dropdown list when Combo or DropDownList EditType is used.

1 - Add Categories table to JSNorthwindDataSet. To add a table to an existing DataSet, in the Data Sources window, click in the "Configure DataSet" wizard button and check the table you want to add in the dialog that appears.

2 - Build the application so you can see CategoriesTableAdapter component in the tool box.

3 - Drag CategoriesTableAdapter component from the toolbox and drop it into the form.

In Tutorial 3 project, you could see that we are calling the FillCategoriesValueList method in the Load event of the form.

To have a ValueList in a column you must:

4 - Set the HasValueList property of the column equal to True. This is necessary to be able to get a ValueList from the ValueList property of the column; otherwise the property will return null (nothing in Visual Basic)

5 - Get the ValueList object from the column:

GridEXValueListItemCollection ValueList = column.ValueList;

6 - Fill the ValueList. To fill a ValueList you have two options:

6.1 - Use the Add method for each value item.

ValueList.Add(1, "Text 1")

ValueList.Add(2, "Text 2")

6.2 - Use the PopulateValueList method if you already have a list of objects or a DataView. When using this method, you must specify the ValueMember and DisplayMember.

ValueList.PopulateValueList(

tableCategories.DefaultView,

"CategoryID",

"CategoryName")

7 -(optional)(recommended) Set the CompareTarget and DefaultGroupInterval properties of the column equal to Text. When you sort or group a column, the control by default uses the value it retrieves from its DataSource, setting these properties, you are instructing the control to sort using the replaced values (in this case, the control will sort category names instead of sorting the category id’s).

8 - (optional) set the EditType property of the column equal to Combo or DropDownList.

Source Of Information : Janus v3.5 Help Files for VS 2008

Adding an Unbound Image Column [Janus GridEX WinForms Control v3.5 for .NET]

2010-07-14T01:23:00.000+08:00

Follow these steps to add an Image column to a table in a GridEX control:

1 - Add an image list to Form1.

2 - Add two images to imageList1 product.bmp and header.bmp

3 - In the ExternalImageList property of the GridEX control, select imageList1.

4 - Go to GridEX Designer dialog and select Columns collection of the RootTable object.

5 - In the Columns panel, Click Add button to add a new column.

Select "Unbound Column" option and enter Icon in the Key text box.

In the next step, Clear the caption of the column and select Image as the ColumnType for the new column.

Click OK

9 - In the property grid, set the ImageKey property equal to "product.bmp". Doing this, you are instructing the column to display that image in all the cells of the column.

10 - To display an image in the header of the column, use the HeaderImageKey property. In this tutorial, we used header.bmp.

11 - Use the MoveUp button in the toolbar to move this column up to be the first column in the control.

12 - Change the Width of the Column to 20 (pixels) and set the AllowSize property equal to false.

13 - Since an image can not be sorted nor grouped, set the AllowGroup and AllowSort properties equal to false.

14 - Save the form and press F5 to run the project.

Source Of Information : Janus v3.5 Help Files for VS 2008