Infragistics JQuery controls

Complete coverage of your source code with NDepend part 1

What is NDepend? This article is part one of a two part series about one of the most practical and dynamic tools in existence for .NET development.  I’m talking about NDepend  I was approached about writing a review for NDepend so I downloaded the application to give it a try.  As with all of my reviews, let it be known that if I think a product is mediocre, then that’s what I’m going to write.  All that to say that this is no exaggeration, I really feel this strongly about this tool.  I’m sure by the end of this article, I will have peeked your interest too.  If you are interested, please read on. NDepend pro product suite From, “NDepend is a Visual Studio tool to manage complex .NET code and achieve high Code Quality.”  This tool allows you to visualize your source code in many different ways in an effort to analyze the quality of your code and how to improve it.  The product comes complete with a Visual Studio add in, an independent GUI tool, and a set of power tools that are console based which makes the product suite extremely versatile.  Whether you are pressed for time and need to analyze your code while in visual studio, you prefer a standalone GUI, or you are addicted to the command line, this product is made to fit your needs. Installation The NDpend installation process is very straight forward.  The download is a zip file that contains the complete product suite.  You simply pick a folder to install to and unzip the archive.  If you’ve purchased the pro version, you will be provided with a license in the form of an XML file which needs to be placed in the directory that you chose to install the product. Installing the Visual Studio 2012 add-in Once you’ve unzipped the archive, you need to run the NDepend.Install.VisualStudioAddin.exe executable to install the Visual Studio add-in. Running the install The installation completed Adding an NDepend project to your solution When you use the Visual Studio integration, you need to create an NDepend project in the solution that you wish to analyze. NDepend will tell you anything that wish you know about source code.  This is powerful, however, it’s a point that must be covered.  In order to be productive with NDepend, you must first define what information that you wish to discover about your source code and how you plan to use that information.  If you don’t have this information then you will not get much use from the product.  The information that it provides to you is very useful, however, you must take some time to plan out how you will use this information to benefit you and your coding efforts. You may wish to make sure that your code maintains a consistent amount of test coverage.  Perhaps you wish to make sure that all methods in your codebase stay below a certain threshold regarding the number of lines of code that they contain.  NDepend is capable of telling you this and much more about your source code. One of the coolest features that I’ve seen in the product is the Code Query Linq (CQLinqing).  This allows you to query your source code using LINQ syntax to bring back anything that you wish to know about your source code.   You can query an assembly, a class, even a method.  The product comes with predefined CQLinq rules but also allows you to create your own rules as well as edit existing rules. I plan to write another blog post that explains my personal experience with the product.  I’ve recently joined an open source project that is a framework that handles some very advanced topics such Artificial intelligence, Machine learning, and language design.  The project is called neural network designer .  I chose this project because the source code is vast and I believe that a large code base is a perfect target to use NDepend to get the most benefit. I plan to use the product and test the following areas:   What information do I want to know about my code base?   When do I wish to be presented with this information?   How do I plan on using this information to improve my code?   How can I use NDepend to provide this information? I think that if you wish to get any use out of the product, it will be very important that you answer these questions.  The product is vast and diverse but it can also be a bit intimidating.  With that said, I plan to use my next post to illustrate how I was able to use NDepend to define the metrics that I needed from my code, and how I used NDepend to provide those metrics to me. Stay tuned for the next installment which will explain my experience with using NDepend to improve my development efforts and my source code. Thanks for reading, Buddy James kick it on

WPF Validation tutorial for the rest of us. Learn to use IDataErrorInfo to automatically validate your views.

    WPF Validation for mere mortals I've recently jumped on the WPF bandwagon and I've fallen in love with this technology.  XAML is a fascinating animal indeed.  The declarative nature of the language leaves much to be explored.  There are many ways to solve the same problem.  On my quest for knowledge, I've been researching the intrinsic validation functionality of WPF.  Unfortunately, most every example I've ran across on blog posts and have been a bit too complex for my blood.  I find often that you need learn other subjects before you can begin to understand how the validation works.  Don't get me wrong, the examples are really nice.  However, when I'm learning something, I want a straight to the point example of the topic at hand.  It's with this idea in mind that I bring you a simple tutorial on WPF validation. I will be illustrating this example using the MVVM (Model-View-ViewModel) Pattern.   Click here to download the entire source (74.08 kb)  Consider the following code  The view MainWindow.xaml <Window x:Class="ExceptionValidation.MainWindow" xmlns="" xmlns:x="" xmlns:viewModel="clr-namespace:ExceptionValidation" Title="MainWindow" Height="350" Width="525" > <Window.Resources> <viewModel:MainWindowViewModel x:Key="mainViewModel"/> </Window.Resources> <StackPanel DataContext="{Binding Source={StaticResource mainViewModel }}"> <TextBlock>Enter total amount</TextBlock> <TextBox Width="200" Name="txtTotalAmount" > <Binding Path="[0].TotalAmount" ValidatesOnDataErrors="True"> <Binding.ValidationRules> <ExceptionValidationRule></ExceptionValidationRule> </Binding.ValidationRules> </Binding> </TextBox> <Button Content="Button" Height="28" Name="button1" Width="84" /> </StackPanel> </Window>     The viewmodel MainWindowViewModel.cs using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; using System.Text; using System.ComponentModel; namespace ExceptionValidation { class MainWindowViewModel : ObservableCollection<Product> { public MainWindowViewModel() { Add(new Product { TotalAmount = 3 }); } } }   The model Product.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.ComponentModel; namespace ExceptionValidation { public class Product : INotifyPropertyChanged , IDataErrorInfo { public event PropertyChangedEventHandler PropertyChanged; private int _totalAmount = 5; public int TotalAmount { get { return _totalAmount; } set { _totalAmount = value; OnPropertyChanged("TotalAmount"); } } public void OnPropertyChanged(string info) { PropertyChangedEventHandler handler = PropertyChanged; if (PropertyChanged != null) { handler(this, new PropertyChangedEventArgs(info)); } } public string Error { get { throw new NotImplementedException(); } } public string this[string columnName] { get { if (columnName == "TotalAmount") { bool valid = true; if (_totalAmount > 10) { valid = false; } if (!valid) { return "The total amount cannot exceed 10!"; } } return null; } } } } A brief introduction to MVVM  As you can see, we have a XAML view, a viewmodel class, and a model.  The Model is a representation of an object's data.  In this instance, we are modeling a Product.  The viewmodel is an object that handles the change notification between properties in the model and elements on the view.  XAML properties, events, and bindings have the ability to tunnel (down the tree) as well as bubble (up the tree).   Binding the ViewModel to the view. In order to bind the ViewModel to the view, we must make it accessible to the view via XAML.  To accomplish this, we first have to import the namespace in which the viewmodel exists.  Examine the following code. xmlns:viewModel="clr-namespace:ExceptionValidation" Here is the equivalent in c# using ExceptionValidation; Once we've imported the namespace for use, we then need to define our MainWindowViewModel as a Resource of the current window. <Window.Resources> <viewModel:MainWindowViewModel x:Key="mainViewModel"/> </Window.Resources> This allows us to declare an instance of the MainWindowViewModel class by using the associated Key "mainViewModel". Binding the ViewModel As stated before the ViewModel acts as a "go between" for the View and the Model.  In order for the view model to communicate with our XAML view, we will bind the ViewModel to the StackPanel's DataContext. <StackPanel DataContext="{Binding Source={StaticResource mainViewModel }}"> XAML's ability to tunnel properties down from parent to child will allow each element inside the stack panel to make use of the DataContext binding that we've just setup using the Window resource's key mainViewModel. ObservableCollection<T> The viewmodel inherits from ObservableCollection<Product>.  The ObservableCollection<T> generic class represents a collection that can be utilized by WPF databinding.  This is possible because the ObservableCollection<T> class raises an event when items are added and removed from the collection. INotifyPropertyChanged The model implements the INotifyPropertyChanged interface.  This interface provides an event in which to fire any time a model property is changed.  This event notifies the bound element in the view that the property has changed. public event PropertyChangedEventHandler PropertyChanged;   public void OnPropertyChanged(string info) { PropertyChangedEventHandler handler = PropertyChanged; if (PropertyChanged != null) { handler(this, new PropertyChangedEventArgs(info)); } }   IDataErrorInfo The magic behind WPF validation comes from the implementation of the IDataErrrorInfo interface.  The interface implements the following members.  The this[columnName] indexer implements the logic of the validation rule. //Not used by WPF public string Error { get { throw new NotImplementedException(); } } public string this[string columnName] { get { if (columnName == "TotalAmount") { bool valid = true; if (_totalAmount > 10) { valid = false; } if (!valid) { return "The total amount cannot exceed 10!"; } } return null; } } The following XAML code binds the TotalAmount property of the first Product in the viewmodel's internal collection to the Text property of the TextBox element.  The ValidatesOnDataErrors attribute tells the textbox binding to raise an event when there is a valadation error.  When the event is raised, the bound element's template is changed to a new visual style that places a Red rectangle around the border of the TextBox.  When the error is corrected, the original template is restored.  Binding.ValidatesOnDataErrors <TextBox Width="200" Name="txtTotalAmount" > <Binding Path="[0].TotalAmount" ValidatesOnDataErrors="True"> </Binding> </TextBox> In the provided example, if you enter a value greater than 10 into the text box and tab out of the textbox, you will see that an error is raised causing the red outline around the textbox.  If you correct the error by replacing the value with a number less than 10, the red outline will disappear. This concludes my tutorial on WPF validation.  This is the very basic of validation methods.  There are many other advanced tutorials on the subject.  My next tutorial will involve utilizing custom validation attributes from the System.ComponentModel namespace to handle WPF view validation. Thanks for reading! ~/Buddy James kick it on  

Learning ILAsm, the backbone of .NET

Who cares about ILAsm or x86 assembly language anyway? I'm sure a lot of you are wondering why anyone would care about learning ILAsm.  It's not like you ever see it unless you disassemble an application.  ILasm or MSIL is the human readable translation of Microsoft .NET intermediate language.  ILAsm is a lot like classic assembly language.  It is a low level programming language that allows you to write programs one instruction at a time with a very minimal syntax.  I've explained the benefits of learning assembly language in my previous post, Why Learn Assembly Language.  In a nutshell, if you learn .NET at the low level of IL, you will have an understanding of what makes any .NET language tick.  You will have the knowledge to disassemble any .NET binary and debug your software at the instruction level.   This post is my first tutorial on writing code in ILAsm.  I hope you'll join me and become proficient in this language of kings.  You will have an edge over the competition and it will change the way you look at high level coding.  Enough talking, let us code! How to compile ILasm If you are a .NET developer, you most likely have an ILasm compiler on your computer which by the way is appropriately named ILasm.exe.  Simply launch the Visual Studio Command Prompt, navigate to the folder that you create your IL files and issue the following command. ilasm.exe is fine if you like to write code in notepad and drop out to a command prompt to write your code.  I myself prefer an IDE.  Visual Studio is an amazing IDE but for some reason the people over at Microsoft didn't see it fit to add support for ILasm into the product.  Never fear!  There is a free, open source alternative that is nearly identical to Visual Studio and it allows you to create and compile IL projects with syntax highlighting that works on Linux, Windows, and Mac OSX!  What is this application you ask? MonoDevelop   "Hello... World?" I know, I know, it's a tired, worn out cliche but far be it from me to interrupt the order of the programming gods and illustrate a programming language without starting with the infamous "Hello World!" example. //import the mscorlib assembly to give us access to Console and other basic classes .assembly extern mscorlib{} //define our assembly .assembly HelloAssembly { //define the version of this assembly .ver 1:0:0:0 } //define the executable module .module helloworld.exe //defin our main method .method static void main() cil managed { //set up the stack. In ILAsm, all values are placed on the stack and then manipulated. //here we will allocate memory for one value to be on the stack at a given time .maxstack 1 //define the main entry point to the application .entrypoint //load the emphamis phrase on the stack ldstr "Hello ILAsm!" //print the string from the stack to the console call void [mscorlib]System.Console::WriteLine(string) //return to end the program ret } If you have never seen asm or ILasm, I can imagine how strange this code snippet may look.  As I've stated before, ILasm is a very cryptic, low level language.  Let's breakdown the application. We start by importing the mscorlib library which contains much of the base .NET classes.  As the comments state, this library gives us access to the System.Console object.   Next, we define the assembly for our program.  All .NET executables are called assemblies.  Here we name our assembly as well as set a version number.  After we define our assembly, we define the executable module.  This is required in any ILasm application.   Now it's time to define our main method that performs the loading and printing of the string.  We start by defining the maxstack, that is, the maximum number of values that can be held in memory at a given time.  In ILAsm, you push values on the stack, perform operations on the values or use them as parameters to methods.  Since we have a maxstack of one, that means we can have only one piece of data to work with at any given time.  We use ldstr to load a string onto the stack.  If we were to load another string on the stack directly after the first ldstr call, the application will simply push the first value out of memory and the new string will be available to access. Finally, we call the WriteLine method on the System.Console object and we tell it to use the current string on the stack as it's input source.   So now you can load a string onto the stack and display it.  It's pretty interesting, although very limited as well.  How about we work with more than one value?  Let's try adding two numbers! Sum it up //reference to mscorlib .assembly extern mscorlib {} //define our assembly .assembly MiniCalculator { //the assembly version number .ver 1:0:0:0 } //create the required module .module MiniCalculator.exe //define our main method .method static void main() cil managed { //we plan to work with two integers this time .maxstack 2 //the main entry point to our application .entrypoint //load a string of instructions on the stack ldstr "OK. Class is in session. Who can tell the class what is the sum of 2 + 2? That's right, the answer is " //display the instructions to the user call void [mscorlib]System.Console::Write (string) //put the number 2 on the stack. Currently the previously loaded string, and the //number 2 are both on the stack. ldc.i4 2 //when we move another integer to the stack, this pushes the string off //now we have two instances of the number 2 on the stack ldc.i4 2 //add will add the two numbers on the stack and store the result add //lets tell the computer to look for an int on the stack and print it to the console call void [mscorlib]System.Console::Write (int32) //return to exit the application ret } We start the application as before by importing mscorlib, defining our assembly and module, and creating the method to perform our work.  We then load a string on the stack and use Console's WriteLine method to display the string.  We then load two integers onto the stack, pushing the string off of the stack.  We call add whichs adds the two integers and stores the result on the stack.  We use Console's WriteLine once again to display the answer. This concludes part one of my ILasm tutorial series. Please check back soon for my next installment in which we will tackle data types, loops, and classes! Until next time.. ~/Buddy James kick it on  

.NET Enumerated Types Explained

  My codeproject article on .NET enumerated types. Introduction The purpose of this article is to provide an introduction to .NET enumerated types. Background Code readability is a big factor when considering the quality of source code. The easier code is to understand, the easier it is to maintain. Have you ever found yourself using numbers to represent a range of variable values? For example:  Collapse | Copy Code Dim CalculationOperation As Integer = 0 CalculationOperation = _ GetOperation () Select Case CalculationOperation Case 1 ’ Addition _PerformAddition() Case 2 ‘ Subtraction _PerformSubtraction() Case 3 ‘ Multiplication _PerformMultiplication() End Select This requires you as well as any other developers that might touch your code to remember all of the possible numeric values that represents colors. This can be a maintenance nightmare! To solve this problem, VB.NET has enumerated types. Reasons to Use Enumerated Types Readability From Wikipedia: "In computer programming, an enumerated type (also called enumeration or enum) is a data type consisting of a set of named values called elements, members or enumerators of the type. The enumerator names are usually identifiers that behave as constants in the language." Enumerated types allow you to give an English description to a range of integer values. Perhaps an example will explain this.  Collapse | Copy Code Public Type CalculatorOperations Addition = 1 Subtraction = 2 Multiplication = 3 End Type Dim Operation As CalculatorOperations Operation = _ GetOperation () Select Case Operation Case CalculatorOperations.Addition _PerformAddition() Case CalculatorOperations.Subtraction _PerformSubtraction() Case CalculatorOperations.Multiplication _PerformMultiplication() End Select     This routine is easier to read. When coding a routine, be sure to consider numeric literals that represent a value other than the number itself as a possible reason to create an enumerated type. Enums as Routine Parameters Enumerated types are great as routine parameters. Consider the following example. Bad Example  Collapse | Copy Code Dim ApplicationState as Integer = 5 ‘lets say five stands for Fatal Crash! Sub _SetApplicationState(ByVal State As Integer) Good Example  Collapse | Copy Code Dim ApplicationState As AppState = AppState.FatalCrash Sub _SetApplicationState(ByVal State As AppState) If you are using Visual Studio, then you no doubt have noticed the benefit of using enumerated types as function parameters. While you are writing the code to call the routine, intellisense will show you all available members of the enumerated type. Compiler Type Checking Using enumerated types also provides type checking by the compiler. Consider the following block of code:  Collapse | Copy Code ‘Valid color values are 0 – 9 Dim CurrentColor As Integer CurrentColor = 12 ‘invalid color This is impossible with enumerated types. Enumerated types can make powerful return values. Consider the following code:  Collapse | Copy Code Dim LoginResult As Boolean = false LoginResult = _AttemptLogin() If LoginResult = True Then _Authenticateuser() End If If LoginResult = False Then _InitiateLogin() End If As you can see, true and false allow for two conditions:  Collapse | Copy Code Dim LoginResult As AuthResult LoginResult = _AttemptLogin() If LoginResult = AuthResult.Authenticated Then _Authenticateuser() End If If LoginResult = AuthResult.Failed Then _InitiateLogin() End If If LoginResult = AuthResult.Suspended Then _AlertSuspended() End If If LoginResult = AuthResult.AuthenticatedChangePassword Then _InitiatePasswordChange() _AuthenticateUser() End If Do you see the possibilities? Define the First and Last Entry as Loop Limits You may find yourself in a situation where you need to iterate through each member of your enumerated type. One suggested practice is to reserve the first and last element as loop limits.  Collapse | Copy Code Public Type RGBValue RGB_FirstValue = 0 RGB_Red = 0 RGB_Green = 1 RGB_Blue = 2 RGB_LastValue = 2 End Type Dim RGBVal As RGBValue For RGBVal = RGBValue.RGB_FirstValue To RGBValue.RGB_LastValue ‘process here Next Here is an example of iterating through an enum. 'Imagine if you had an enum for EmployeeTypes and you 'wanted to iterate over 'each employee type and perform an 'action. 'For instance Public Type EmployeeType  Cashier = 0  Supervisor = 1  Manager = 2  Executive = 3 End Type Dim employeeType As EmployeeType For employeeType = EmployeeType.Cashier To EmployeeType.Executive  CalculateRaise(employeeType) Next Conclusion Well, I hope I’ve illustrated some of the benefits of using enumerated types. All of your feedback is welcome.   kick it on  

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 (, 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