Infragistics ASP.NET controls

Dependency Injection and Inversion of Control Ioc With the Microsoft Unity Container

Design for Reusability A well designed application should promote code reuse whenever possible.  Code reuse can save you time and money by allowing you to use components from previous applications to solve common problems in new projects.  The task of managing dependencies is one of the many concerns a developer faces when designing for reusability.  Dependencies are any classes that a particular class must directly instantiate and use in order to accomplish a task.  As a rule of thumb, it's good object oriented programming practice to code to an interface rather than a concrete implementation.  This will make your code flexible and built for change.   An example of a dependency You've been tasked to write a console application.  The application requires that the user authenticates before using any of the features and there is a requirement that all successfully log-ins are logged to a text file.  Here is the code for the example. TextLogger.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public class TextLogger { public void LogMessage(string message) { //Code to write the message to a text file.... Console.WriteLine(string.Format("Logging the message to a text file: {0} ", message)); } } }   AuthenticationService.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public class AuthenticationService { public AuthenticationService() { } internal void Authenticate(string userName, string password) { //Authentication logic goes here TextLogger logger = new TextLogger(); logger.LogMessage("Login was successful"); } } }   Program.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { class Program { static void Main(string[] args) { AuthenticationService authenticationService = new AuthenticationService(); authenticationService.Authenticate(); } } } This is a basic example for demonstration purposes only.  Now, as you can see in the AuthenticationService Authenticate method we are instantiating an instance of the TextLogger class.  So now a few weeks pass by and the customer wants you to log to a database instead of a text file.  So you create  a new class. DBLogger.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public class DBLogger { public void LogMessage(string message) { //Code to write the message to a database.... Console.WriteLine(string.Format("Logging the message to a database: {0} ", message)); } } } The AuthenticationService was dependent on the TextLogger and is now dependent on the DBLogger class.  The current design requires us to change the AuthenticationService any time the customer requests a new type of logger.  The same holds true for any unit tests that we write that uses a Logger class.  As you can see the design promotes tight coupling because we are coding to a concrete implementation which is not very flexible. Introducing an interface As we can see, both logger classes have one method called LogMessage.  They share the same interface.  This is a perfect example of an instance in which we should code to an interface.  So we start by creating an interface that matches the two logging classes. ILogger.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public interface ILogger { void LogMessage(string message); } } Now we could simply change the logger declaration in the AuthenticationService and be done with it, however, there are still some optimizations that can be achieved.  For instance, currently the Logger declaration is a local variable inside of the Authenticate method.  Imagine were to inject the ILogger as a parameter of the AuthenticationService constructor.  This is a much more flexible design because the AuthenticationService only has knowledge of an ILogger.  Since the implementation is injected via the constructor, the class is no longer tied to any one specific implementation. Here is the updated AuthenticationService.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public class AuthenticationService { //the logger is now a class field private ILogger logger; public AuthenticationService(ILogger implementation) { //The implementation is injected via the constructor logger = implementation; } internal void Authenticate(string userName, string password) { //Authentication logic goes here logger.LogMessage("Login was successful"); } } } DBLogger.cs updated using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace UnityExample { public class DBLogger : ILogger { public void LogMessage(string message) { //Code to write the message to a database.... Console.WriteLine(string.Format("Logging the message to a database: {0} ", message)); } } } The Unity Container The Unity container allows us to use code (or a configuration file) to associate an interface with a class.  This is typically done during your application start up or the set up of your unit tests.  You register your interface and class mappings.  Then later when it's time to instantiate an instance of your objects, you ask the container to resolve an instance of the object that you need.  The Unity container will perform an internal look up and it will resolve any dependencies that your object's constructor depends on.   I prefer to register my interface/class mappings in a class that I call a module.  When my application starts I load all modules to prepare the container to resolve all of the objects that I will need.  This abstraction allows you to easily switch an interfaces implementation at run time providing a high level of flexibility to your code.  Here is a brief example of how to use the Unity container.  You will need to download the Unity assemblies from nuget or from the Microsoft patterns and practices Unity Application block site.http://unity.codeplex.com/ LoggingModule.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Microsoft.Practices.Unity; namespace UnityExample { public class LoggingModule { IUnityContainer _iocContainer; public LoggingModule(IUnityContainer container) { _iocContainer = container; } public void Init() { //Add any logic here to look in a config file, check a property //or any other condition to decide which implementation is registered. //register the database logger to the ILogger interface _iocContainer.RegisterType(typeof(ILogger), typeof(DBLogger)); } } } Updated Program.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Microsoft.Practices.Unity; namespace UnityExample { class Program { private static IUnityContainer _iocContainer; static void Main(string[] args) { //create our container _iocContainer = new UnityContainer(); InitializeModules(); //the container knows how to create an AuthenticationService object //as well as what type of ILogger it takes because we registered //the required class in the loggerModule. var authenticationService = _iocContainer.Resolve<AuthenticationService>(); authenticationService.Authenticate("username", "password"); Console.WriteLine("press any key"); Console.ReadKey(); } private static void InitializeModules() { //pass the container to the module //so when we register the types we can resolve them var loggingModule = new LoggingModule(_iocContainer); loggingModule.Init(); } } }   This is a very basic introduction to Unity but you I hope that you can see the possibilities when you program to interfaces and let the container take control of object creation.  You could extend this example to create a ModuleInitializer class that takes the modules that need to be initialized.   The bottom line is Program to interfaces Inject dependencies via the constructor Register your dependency interfaces to the desired class in the unity container.  You can use a module approach if you so choose. As long as your interfaces are mapped to classes in your container, the container can resolve any dependencies that your object requires when instantiated. Download the source  UnityExample.zip (723.64 kb) Happy coding! kick it on DotNetKicks.com


Navigation design for Windows Store apps and other Windows 8 design resources

Windows 8 Developer resources If you are a Windows developer then I'm sure you will agree that we are living in a very interesting time.  In light of the launch of Windows 8, Microsoft has launched a very ambitious campaign in an effort to win the interest of developers.  What's most impressive is the amount of developer resources that Microsoft has developed to teach developers how to design and develop applications for Windows 8 and the Windows App Store. I recently ran across a site that dedicated to helping developers create a Windows 8 application and publish to the App store in 30 days.  This Microsoft funded site has divided 30 days into daily tasks and articles that will lead you on the way to developing your first Windows 8 application.  They've even offered a free 1:1 consultation with an expert developer via telephone to assist with development.  They've provided Windows 8 PhotoShop design templates for download, example applications and tons of other design and development resources. The official Windows 8 release is just around the corner but Microsoft has provided a full featured 90 day trial version of Windows 8 for developers to download so they don't have to wait to begin developing their applications.   I think Microsoft is taking all the right steps to get our attention and I'm excited about the road ahead.  I would like to see a little more along the lines of .NET development in the world of Windows 8 as well as more resources for learning WinRT.  In any case, Microsoft, I say kudos to you.  I plan to take advantage of the resources and I will track my 30 day application experience in a series of blog posts.  Stay tuned.   Resources      Dev Center - Windows Store apps  http://msdn.microsoft.com/en-US/windows/apps/br229512   Navigation design for Windows Store apps http://msdn.microsoft.com/en-us/library/windows/apps/hh761500  kick it on DotNetKicks.com        


Export Microsoft Office documents from ASP.NET applications using Infragistics NETADVANTAGE for ASP.NET

INFRAGISTICS I have a lot of experience developing applications using the Infragistics NETADVANTAGE for ASP.NET controls.  I've recently downloaded the latest control suite and I've decided to write a series of articles on the different controls and how they are used.  This article will be focused on creating Microsoft Word, Microsoft Excel, PDF, and XPS documents using the Infragistics NETADAVANTAGE for ASP.NET Controls. Exporting PDF and XPS documents from the contents of the WebDataGrid The Infragistics control suite is complete with two fully functional web grid controls.  The WebDataGrid provides a high performance, scalable ASP.NET AJAX enabled grid with built in support for sorting, filtering, and editing tabular data.  The control is designed with touch enabled devices in mind.  There is also built in support for flicking and other multi-touch gestures.   Here is an screen shot of the WebDataGrid for your review    As you can see, the grid is sleek, stylish, and very pleasing to the eye.  Infragistics controls have many predefined styles, as well as rich server side and client side  APIs.  The second Infragistics grid control is the WebHierarchicalDataGrid.  The WebHierarchicalDataGrid shares the same functionality as the WebDataGrid as well as the ability to model master-detail and self referencing data relationships.  These relationships are represented by expandable rows that contain the related data inside of a parent row.   Here is a screen shot of the WebHierarchicalDataGrid.     Both of the grids feature the ability to export the contents of the grid's data source to Microsoft Excel, Microsoft Word , PDF, and XPS documents.  There's also built in support for importing the contents of an Excel spreadsheet to populate the data grids. Microsoft Office independence One of the greatest features of the Microsoft document export functionality is the fact that there is no need to have Microsoft office installed on the server to generate the resulting documents.  The Infragistics library uses 100% managed .NET assemblies to implement this functionality.  This means there's no need to hack around the Word or Excel COM interop libraries to achieve the desired results.  Infragistics NETADVANTAGE comes with a Word Document object model as well as an Excel Woorkbook object model which provide rich APIs for creating Microsoft Office documents for use in your applications.  You can generate invoices, work orders, and receipts with very little code. My next article will include a fully functional sample that illustrates some of the functions of the WebDataGrid as well as the document export functionality. This concludes the article.  Thanks for reading! You can download a trial of the entire .NET NETADVANTAGE control suite by visiting the following URL:  http://www.infragistics.com/products/dotnet/ Infragistics website http://www.infragistics.com/ And here are some useful videos to get you started Export Grid Data to Excel Export Grid Data to PDF and XPS formats   kick it on DotNetKicks.com


Implementing a re-sizable composite view user interface using the MVVM pattern, the GridSplitter, and WPF UserControls.

  A composite view user interface In the world of WPF, the Model-View-ViewModel pattern is a great way to separate your UI from your business logic.  This decoupling allows you to easily unit test your code.  When implemented correctly, the MVVM pattern promotes a view agnostic structure which makes switching between different views extremely easy.  A composite view UI is basically a user interface that is made up of multiple independent views.  By independent, I mean that the views should be decoupled and unaware of each other.  In this tutorial, I will show you how to create the following UI.     Existing frameworks There are several existing frameworks that facilitate the implementation of the MVVM pattern and composite view applications.  MVVM Toolkit, MvvMLight, SoPrism, and Prism are a few examples of some of the existing libraries out there.  Prism is probably the most complete and extensive but it also has a large learning curve.  I decided that before I dive into learning the details of Prism, I would benefit by trying to code a composite application by hand.  The User Interface design The previous screen shot shows an application made up of a Window that contains a grid, a listview, and a ContentControl.  The ContentControl and ListView are separated by a GridSplitter control.  This allows the two views to be re-sized.  The ContentControl will have a UserControl injected into the content property as the ListView's selected item is changed. Here is the XAML markup <Window x:Class="OutlookLayoutPresenter.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:views="clr-namespace:OutlookLayoutPresenter.Views" Title="MainWindow" Height="350" Width="525"> <Grid> <Grid.ColumnDefinitions> <ColumnDefinition Width="128*" /> <ColumnDefinition Width="375*" /> </Grid.ColumnDefinitions> <ListView SelectionChanged="lstMenu_SelectionChanged" IsSynchronizedWithCurrentItem="True" DisplayMemberPath="MenuDisplayText" x:Name="lstMenu"> </ListView> <ContentControl Grid.Column="1" Content="{Binding Path=Presenter.CurrentView}" x:Name="MainContent"> </ContentControl> <GridSplitter Grid.Column="1" Width="2" HorizontalAlignment="Left" /> </Grid> </Window> As you can see, we have a Grid with two columns.  The column on the left holds a ListView that that is data bound in the code behind.  The ContentControl's content property is also data bound to the Presenter.CurrentView property of our ViewModel.  I chose to implement a presenter object to handle the injection of the UserControl into the ContentControl.  We will start with the codebehind of our view to show how we are setting the DataContext. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Navigation; using System.Windows.Shapes; using OutlookLayoutPresenter.Views; namespace OutlookLayoutPresenter { /// <summary> /// Interaction logic for MainWindow.xaml /// </summary> public partial class MainWindow : Window { private MainWindowViewModel _viewModel; public MainWindow() { InitializeComponent(); _viewModel = new MainWindowViewModel(); this.DataContext = _viewModel; lstMenu.ItemsSource = _viewModel; } void lstMenu_SelectionChanged(object sender, SelectionChangedEventArgs e) { var menuItem = (ViewMenuItems)e.AddedItems[0]; _viewModel.Presenter.DisplayView(menuItem); } } } Note that we have bound our ViewModel to the view's DataContext as well as the ListView's ItemsSource property.  The ViewModel is an ObservableCollection of ViewMenuItem objects.  I created the ViewMenuItem class to contain the region's name and the display text.  The ListView serves as a menu.   Here is the code for the ViewMenuItem class. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.ComponentModel; namespace OutlookLayoutPresenter { public class ViewMenuItems : INotifyPropertyChanged { private string _regionName; private string _menuDisplayText; public string RegionName { get { return _regionName; } set { if (_regionName == value) return; _regionName = value; OnPropertyChanged("RegionName"); } } public string MenuDisplayText { get { return _menuDisplayText; } set { if (_menuDisplayText == value) return; _menuDisplayText = value; OnPropertyChanged("MenuDisplayText"); } } public event PropertyChangedEventHandler PropertyChanged; protected void OnPropertyChanged(string propertyName) { var handler = PropertyChanged; if (handler != null) { handler(this, new PropertyChangedEventArgs(propertyName)); } } } } When looking at the ViewModel, please be sure to note the public Presenter property that is used in the data binding of the ContentControl. The ObservableCollection of ViewMenuItem objects builds the ListView menu. Here's the ViewModel's code using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.ComponentModel; using System.Collections.ObjectModel; namespace OutlookLayoutPresenter { public class MainWindowViewModel : ObservableCollection<ViewMenuItems> , INotifyPropertyChanged { private IPresenter _presenter; public IPresenter Presenter { get { return _presenter; } set { _presenter = value; OnPropertyChanged("Presenter"); } } public MainWindowViewModel () { this.Add(new ViewMenuItems{RegionName = "RegionOne", MenuDisplayText = "Content One"}); this.Add(new ViewMenuItems{RegionName = "RegionTwo", MenuDisplayText = "Content Two"}); this.Add(new ViewMenuItems{RegionName = "RegionThree", MenuDisplayText = "Content Three"}); this.Presenter = new MainWindowPresenter(); } public event PropertyChangedEventHandler PropertyChanged; protected void OnPropertyChanged(string propertyName) { var handler = PropertyChanged; if (handler != null) { handler(this, new PropertyChangedEventArgs(propertyName)); } } } } All that's left now is the MainWindowPresenter class which will dynamically load one of three user controls based on the ListView's selected item. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.ComponentModel; using System.Windows.Controls; using OutlookLayoutPresenter.Views; namespace OutlookLayoutPresenter { /// <summary> /// This is the presenter class for the main Shell. the purpose of this /// class is to contain all of the UI event handlers for the main shell view. /// </summary> public class MainWindowPresenter : INotifyPropertyChanged, IPresenter { ContentControl _currentView = new ContentControl(); public ContentControl CurrentView { get { return _currentView; } set { _currentView = value; OnPropertyChanged("CurrentView"); } } public void DisplayView(ViewMenuItems item) { switch (item.RegionName.ToUpper()) { case "REGIONONE": this.CurrentView.Content = new ContentOne(); break; case"REGIONTWO": this.CurrentView.Content = new ContentTwo(); break; case "REGIONTHREE": this.CurrentView.Content = new ContentThree(); break; } } public event PropertyChangedEventHandler PropertyChanged; protected void OnPropertyChanged(string propertyName) { var handler = PropertyChanged; if (handler != null) { handler(this, new PropertyChangedEventArgs(propertyName)); } } } } There are three user controls that have a different background color and text.  I will show the markup for one of the controls for brevity. <UserControl x:Class="OutlookLayoutPresenter.Views.ContentOne" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" mc:Ignorable="d" Background="Blue"> <Grid> <TextBlock FontWeight="Bold" Foreground="White" Text="Content One" /> </Grid> </UserControl>   As you click on each menu item, the content view will change colors and text.  I've included the source code for your reference. OutlookLayoutPresenterMVVM.zip (93.27 kb)   This concludes the tutorial.  Thanks for reading! Until next time... Buddy James kick it on DotNetKicks.com      


About the author

My name is Buddy James.  I'm a Microsoft Certified Solutions Developer from the Nashville, TN area.  I'm a Software Engineer, an author, a blogger (http://www.refactorthis.net), a mentor, a thought leader, a technologist, a data scientist, and a husband.  I enjoy working with design patterns, data mining, c#, WPF, Silverlight, WinRT, XAML, ASP.NET, python, CouchDB, RavenDB, Hadoop, Android(MonoDroid), iOS (MonoTouch), and Machine Learning. I love technology and I love to develop software, collect data, analyze the data, and learn from the data.  When I'm not coding,  I'm determined to make a difference in the world by using data and machine learning techniques. (follow me at @budbjames).  

Related links

Month List