All posts by Juan Arguello

.NET Core: Cross Platform – Ubuntu Linux

In the previous posts we briefly described how .NET Core is making .NET cross platform available for Windows, OSX and now Linux!

If you search a little bit you’ll find different instructions to install .NET Core tooling (DNVM, DNX and DNU) on Ubuntu Linux. In this blog post you’ll find the bare minimum steps to get a Hello World sample running in Ubuntu 14.04.

For instance, the docs specify a Mono dependency to make DNU work on Linux. Apparently, this is no longer required ūüôā

Remember, the .NET team is currently working on it and the CoreCLR is work in progress and open source!

.NET Version Manager (DNVM)

The .NET Version Manager helps retrieving versions of the DNX, using NuGet, and allowing you to switch between versions when you have multiple on your machine. DNVM is simply a way to manage and download NuGet packages and it is a set of command line utilities to update and configure which .NET Runtime to use.

We’ll use a little script to download and install DNVM in the machine. This script uses curl and unzip which can be installed with the following command:

sudo apt-get install unzip curl

 

After installing the prerequisites we are ready to download and install DNVM:

curl -sSL https://raw.githubusercontent.com/aspnet/Home/dev/dnvminstall.sh | DNX_BRANCH=dev sh && source ~/.dnx/dnvm/dnvm.sh

 
DNVM_install
After the script is executed you should be ready to go and install DNX. In my case, I had to execute one additional command to source the dnvm.sh and make it available to the console. Helpfully, this hint was provided by the script itself:

Type 'source /home/user/.dnx/dnvm/dnvm.sh' to start using dnvm

 

DNVM

Once this step is complete you should be able to run DNVM and see some help text.

Again, as I said in the OS X post, from this point this post is mostly a copy of my previous .NET Core: Cross platform – Windows post. Which is nice ūüôā

 

.NET Execution Environment (DNX)

The .NET Execution Environment (DNX) contains the code required to bootstrap and run an application. This includes things like the compilation system, SDK tools, and the native CLR hosts.

DNX provides a consistent development and execution environment across multiple platforms (Windows, Mac and Linux) and across different .NET flavors (.NET Framework, .NET Core and Mono).

It is easy to install the .NET Core version of DNX, using the DNVM install command:

dnvm install -r coreclr latest

 

You can then use dnvm to list and select the active DNX version in your system (In my case, the latest version of DNX CoreCLR is 1.0.0-beta8)

dnvm use 1.0.0-beta8 -r coreclr

dnvm list

 
DNVM_list
 

Important: This is not strictly required at this point but before you can DNX run your application you must install some general purpose dependencies. You can install those using the following command:

sudo apt-get install libunwind8 libssl-dev

 

Hello world

A DNX project is simply a folder with a project.json file. The name of the project is the folder name.

Let’s first create a folder, set it as our current directory in command line:

mkdir HelloWorld && cd HelloWorld

 

Now create a new C# file HelloWorld.cs, and paste in the code below:

using System;

public class Program {
    public static void Main(string[] args){
        Console.WriteLine("Hello World from Core CLR!");
        Console.Read();
    }
}

 

Next, we need to provide the project settings DNX will use. Create a new project.json file in the same folder, and edit it to match the listing shown here:

{
    "version": "1.0.0-*",
    "dependencies": {
    },
    "frameworks" : {
        "dnx451" : { },
        "dnxcore50" : {
            "dependencies": {
                "System.Console": "4.0.0-beta-*"
            }
        }
    }
}

 

.NET Development Utility (DNU)

DNU is a command line tool that helps with the development of applications using DNX. You can use DNU to build, package and publish DNX projects. Or, as in the following example, you can use DNU to install a new package into an existing project or to restore all package dependencies for an existing project.

 

Important: The DNU utility has some dependencies on itself. Before you can dnu restore a project packages you must install the dependency using the following command:

sudo apt-get install libcurl3-dev

 

The project.json file defines the app dependencies and target frameworks in addition to various metadata properties about the app. See Working with DNX Projects for more details.

Because the .NET Core is completely factored we need to explicitly pull those libraries that our project depends on. We’ll¬† run the following command to download and install all packages that are listed in the project.json:

dnu restore

 

You’ll notice that even though our project only required System.Console, several dependent libraries have been downloaded and installed as a result.

 
DNU_restore
 

DNX run the app

At this point, we’re ready to run the app. You can do this by simply entering dnx run from the command prompt. You should see a result like this one:

dnx run

 
DNX_run
 

Further reading

https://dotnet.github.io/core/getting-started/

http://docs.asp.net/en/latest/getting-started/installing-on-linux.html#installing-on-debian-ubuntu-and-derivatives

http://www.mono-project.com/docs/getting-started/install/linux/#debian-ubuntu-and-derivatives

Intro to .NET Core

.NET Core: Cross Platform – Windows

.NET Core: Cross Platform – OS X

 

Summary

IHaveNoIdeaWhatImDoing

.NET Core: Cross Platform – OS X

.NET Core is making .NET cross platform an available for Windows, Ubuntu and OSX with a little help of our friends: DNVM, DNU and DNX.

The .NET Execution Environment (DNX) is a software development kit (SDK) and runtime environment that has everything you need to build and run .NET applications for Windows, Mac and Linux.

.NET Version Manager (DNVM)

The .NET Version Manager helps retrieving versions of the DNX, using NuGet, and allowing you to switch between versions when you have multiple on your machine. DNVM is simply a way to manage and download NuGet packages and it is a set of command line utilities to update and configure which .NET Runtime to use.

While it is pretty easy to install DNVM in a Windows box, on OSX the easiest way to get DNVM is to use Homebrew.

Homebrew: Bootstrapping the Bootstrapper

Package managers are the key component that have completely changed the face of modern software development. Homebrew is an OSX package manager which makes easy to install, upgrade and remove software packages.

In a nutshell, it uses GitHub repositories to download software (such as scripts), stores them in its own location and the creates symlinks providing easy access to them.

 

If you don’t have Homebrew installed then follow the Homebrew installation instructions. If you have the Developer tools installed you can use the following script in a terminal window:

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

 

Once you have Homebrew up and running you can use the following commands to install DNVM:

brew tap aspnet/dnx
brew update
brew install dnvm

source dnvm.sh

 

Under the hood, Homebrew cloned the aspnet/homebrew-dnx  repository and installed dnvm using the dnvm.rb script. The dnvm.sh is a bag of functions that need to be sourced, hence the last command executed. Also, it is recommended to check and upgrade to the latest version of DNVM using the following command:

dnvm upgrade

 

DNVM

 

.NET Execution Environment (DNX)

From this point, this post is mostly a copy of my previous .NET Core: Cross platform – Windows post. Which is nice ūüôā

DNX provides a consistent development and execution environment across multiple platforms (Windows, Mac and Linux) and across different .NET flavors (.NET Framework, .NET Core and Mono).

 

It is easy to install the .NET Core version of DNX, using the DNVM install command:

dnvm install -r coreclr latest

 

You can then use dnvm to list and select the active DNX version in your system (In my case, the latest version of DNX CoreCLR is 1.0.0-beta8)

dnvm use 1.0.0-beta8 -r coreclr

dnvm list

DNVM_use_list

 

Hello world

A DNX project is simply a folder with a project.json file. The name of the project is the folder name.

Let’s first create a folder, set it as our current directory in command line:

mkdir HelloWorld && cd HelloWorld

 

Now create a new C# file HelloWorld.cs, and paste in the code below:

using System;

public class Program {
    public static void Main(string[] args){
        Console.WriteLine("Hello World from Core CLR!");
        Console.Read();
    }
}

 

Next, we need to provide the project settings DNX will use. Create a new project.json file in the same folder, and edit it to match the listing shown here:

{
    "version": "1.0.0-*",
    "dependencies": {
    },
    "frameworks" : {
        "dnx451" : { },
        "dnxcore50" : {
            "dependencies": {
                "System.Console": "4.0.0-beta-*"
            }
        }
    }
}

.NET Development Utility (DNU)

DNU is a command line tool that helps with the development of applications using DNX. You can use DNU to build, package and publish DNX projects. Or, as in the following example, you can use DNU to install a new package into an existing project or to restore all package dependencies for an existing project.

DNU

Important: If you are not seeing the output above you might be facing an issue with your OSX installation. By the time I’m writing this, there is a know issue regarding a missing dependency on ICU4C. In my case, I fixed it by brewing the dependency and everything worked like a charm again.

brew install icu4c

 

The project.json file defines the app dependencies and target frameworks in addition to various metadata properties

about the app. See Working with DNX Projects for more details.

Because the .NET Core is completely factored we need to explicitly pull those libraries that our project depends on. We’ll¬† run the following command to download and install all packages that are listed in the project.json:

dnu restore

 

You’ll notice that even though our project only required System.Console, several dependant libraries have been downloaded and installed as a result.
DNU_restore

 

DNX run the app

At this point, we’re ready to run the app. You can do this by simply entering dnx run from the command prompt. You should see a result like this one:

dnx run

DNX_run

 

Further reading

https://dotnet.github.io/core/getting-started/

http://brew.sh/

https://github.com/aspnet/homebrew-dnx

https://github.com/aspnet/dnx/issues/2875

Intro to .NET Core

.NET Core: Cross Platform – Windows

 

Summary

WhatIfIToldYouOSX

.NET Core: Cross Platform – Windows

The .NET Execution Environment (DNX) is a software development kit (SDK) and runtime environment that has everything you need to build and run .NET applications for Windows, Mac and Linux.

However, package managers are the key component that have completely changed the face of modern software development and they’re very tied together in the .NET Core main tools: DNVM, DNU and DNX.

.NET Version Manager (DNVM)

The .NET Version Manager helps retrieving versions of the DNX, using NuGet, and allowing you to switch between versions when you have multiple on your machine. DNVM is simply a way to manage and download NuGet packages and it is a set of command line utilities to update and configure which .NET Runtime to use.
You can use the PowerShell script below to install DNVM. It just downloads an executes the dnvminstall.p1 script from the ASPNET/Home repo.

@powershell -NoProfile -ExecutionPolicy unrestricted -Command "&{$Branch='dev';iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/aspnet/Home/dev/dnvminstall.ps1'))}"

It just installs the dnmv.ps1 command line tool and adds it to the %PATH% environment variable. No version of DNX will be installed at this point. Also, it is recommended to check and upgrade to the latest version of DNVM using the following command:

dnvm upgrade

 

DNVM

DNVM solves the bootstrapping problem of getting and selecting the correct version of the DNX to run. You’ll find that the NuGet gallery hosts cross platform versions of DNX:

.NET Execution Environment (DNX)

The .NET Execution Environment (DNX) contains the code required to bootstrap and run an application. This includes things like the compilation system, SDK tools, and the native CLR hosts.

DNX provides a consistent development and execution environment across multiple platforms (Windows, Mac and Linux) and across different .NET flavors (.NET Framework, .NET Core and Mono).

It is easy to install the .NET Core version of DNX, using the DNVM install command:

dnvm install -r coreclr latest

 
DNX

You can then use dnvm to list and select the active DNX version in your system (In my case, the latest version of DNX CoreCLR is 1.0.0-beta8)

dnvm use 1.0.0-beta8 -r coreclr

dnvm list

 

Hello world

A DNX project is simply a folder with a project.json file. The name of the project is the folder name.

Let’s first create a folder, set it as our current directory in command line:

mkdir HelloWorld && cd HelloWorld

 

Now create a new C# file HelloWorld.cs, and paste in the code below:

using System;
 
public class Program {
    public static void Main(string[] args){
        Console.WriteLine("Hello World from Core CLR!");
        Console.Read();
    }
}

 

Next, we need to provide the project settings DNX will use. Create a new project.json file in the same folder, and edit it to match the listing shown here:

 

{
    "version": "1.0.0-*",
    "dependencies": {
    },
    "frameworks" : {
        "dnx451" : { },
        "dnxcore50" : {
            "dependencies": {
                "System.Console": "4.0.0-beta-*"
            }
        }
    }
}

.NET Development Utility (DNU)

DNU is a command line tool that helps with the development of applications using DNX. You can use DNU to build, package and publish DNX projects. Or, as in the following example, you can use DNU to install a new package into an existing project or to restore all package dependencies for an existing project.
DNU

 

The project.json file defines the app dependencies and target frameworks in addition to various metadata properties
about the app. See Working with DNX Projects for more details.

Because the .NET Core is completely factored we need to explicitly pull those libraries that our project depends on. We’ll¬† run the following command to download and install all packages that are listed in the project.json:

dnu restore

 

You’ll notice that even though our project only required System.Console, several dependant libraries have been downloaded and installed as a result.
DNU_restore

DNX run the app

At this point, we’re ready to run the app. You can do this by simply entering dnx run from the command prompt. You should see a result like this one:

dnx run

Further reading

https://dotnet.github.io/core/getting-started/

https://github.com/aspnet/Home/wiki/Version-Manager

http://docs.asp.net/en/latest/dnx/overview.html

http://docs.asp.net/en/latest/dnx/console.html

Intro to .NET Core

.NET Core: Cross Platform – OS X

Intro to .NET Core

.NET is a general purpose development platform. It has several key features that are attractive to many developers, including automatic memory management and modern programming languages, that make it easier to efficiently build high-quality apps. Multiple implementations of .NET are available, based on open .NET Standards that specify the fundamentals of the platform.

.NET Implementations

There are various implementations of .NET, some coming from Microsoft, some coming from other companies and groups:

  • The .NET Framework is the premier implementation of the .NET Platform available for Windows server and client developers.

    There are additional stacks built on top the .NET Framework, for example Windows Forms and Windows Presentation Foundation (WPF) for UI, Windows Communication Foundation (WCF) for middleware services and ASP.NET as a web framework.

  • Mono is an open source implementation of Microsoft’s .NET Framework based on the ECMA standards for C# and the Common Language Runtime.
  • .NET Native is the set of tools used to build .NET Universal Windows Platform (UWP) applications. .NET Native compiles C# to native machine code that performs like C++.

I’ll explain a little bit more on what is .NET Core below. But first, let’s take a look at the .NET Ecosystem.

.NET Ecosystem

The NET Ecosystem is undergoing a major shift and restructuring in 2015. There are a lot of ‚Äúmoving pieces‚ÄĚ that need to be tied together in order for this new ecosystem and all of the recommended scenarios to work. As you can see, this is a very vibrant and diverse ecosystem.

You might not know but most of these projects are currently open sourced and fostered by the .NET Foundation (independent) organization. Yes! These projects are open source!

 

10kft_view

A wild .NET implementation appeared!

.NET Core is a cross-platform implementation of .NET that is primarily being driven by ASP.NET 5 workloads, but also by the need and desire to have a modern runtime that is modular and whose features and libraries can be cherry picked based on the application’s needs.

It includes a small runtime that is built from the same codebase as the .NET Framework CLR. The .NET Core runtime includes the same GC and JIT (RyuJIT), but doesn’t include features like Application Domains or Code Access Security.

There are several characteristics of .NET Core:

  • Cross-platform support is the first important feature. For applications, it is important to use those platforms that will provide the best environment for their execution. Thus, having an application platform that can enable the app to be ran on different operating systems with minimal or no changes provides a significant boon.
  • Open Source because it is proven to be a great way to enable a larger set of platforms, supported by community contribution.
  • Better packaging story – the framework is distributed as a set of packages that developers can pick and choose from, rather than a single, monolithic platform. .NET Core is the first implementation of .NET Platform that is distributed via NuGet package manager.
  • Better application isolation as one of the scenarios for .NET Core is to enable applications to ‚Äútake‚ÄĚ the needed runtime for their execution and deploy it with the application, not depending on shared components on the targeted machine. This plays well with the current trends of developing software and using container technologies like Docker for consolidation.
  • Modular – .NET Core is a set of runtime, library and compiler components. Microsoft uses these components in various configurations for device and cloud workloads.

NuGet as a 1st class delivery vehicle

In contrast to the .NET Framework, the .NET Core platform will be delivered as a set of NuGet packages.

Using NuGet allows for much more agile usage of the individual libraries that comprise .NET Core. It also means that an application can list a collection of NuGet packages (and associated version information) and this will comprise both system/framework as well as third-party dependencies required. Further, third-party dependencies can now also express their specific dependencies on framework features, making it much easier to ensure the proper packages and versions are pulled together during the development and build process.

If, for example, you need to use immutable collections, you can install the System.Collections.Immutable package via NuGet. The NuGet version will also align with the assembly version, and will use semantic versioning.

 

0841.Pic4

Open Source and Cross-Platform

Last year, the .NET Core main repositories were made open source: CoreFX (Framework libraries) and CoreCLR (Runtime) are public in GitHub. The main reasons for this is to leverage a stronger ecosystem and lay the foundation for a cross platform .NET and it is a natural progression on current .NET Foundation’s open source efforts:

However, as of only a few months ago (April) you can install .NET Core on Windows, Linux and OSX. This makes code written for it is also portable across application stacks, such as Mono, and platforms making it feasible to move applications across different environments with ease.

Windows_Linux_OSX

Further reading

http://blogs.msdn.com/b/dotnet/archive/2014/12/04/introducing-net-core.aspx

http://blogs.msdn.com/b/dotnet/archive/2014/11/12/net-core-is-open-source.aspx

http://dotnet.github.io/core/

http://dotnet.github.io/core/about/

http://dotnet.readthedocs.org/en/latest/getting-started/overview.html

http://dotnet.github.io/core/about/overview.html

.NET Core: Cross Platform – Windows

.NET Core: Cross Platform – OS X

NodeBots Day 2015 – Medellin

El sábado pasado tuve la oportunidad de participar del NodeBots Day 2015 en Medellin @NodeBotsMed. Fue un día realmente muy divertido y el primero de estos eventos en los que participo.

Venue

El lugar donde se realizó el evento me sorprendió gratamente. El edificio de RutaN es bellísimo. Con el estilo que se repite en todo Medellín, esta coloreado de mucho verde y naturaleza.

NodeBots Day Medellin - RutaN

Introduccion

Siguiendo el espíritu de NodeBots Day no hubo una charla formal sino mas bien una introducción por parte de nuestro facilitador @Julian_Duque que nos contó un poco sobre los origenes de Javascript Robotics, un poco de la Serial Port library y el modulo Johnny-Five.

Manos a la obra

Rapidamente nos pusimos todos manos a la obra y provistos de unos SumoBots kit¬†comenzamos armando los sumobots. Los Sumobots son unos modelos¬†open source especialmente dise√Īados para los NodeBots Day, f√°ciles de construir, de ensamblar y muy econ√≥micos. Podr√° parecerles exagerado, pero hac√≠a mucho tiempo que no realizaba trabajos manuales con tecnolog√≠a que ya nos resulta desconocida: Cables, Tornillos, Taladros, Trinchetas, Pegamento, Lijas!!

(Source: MeetupJS)

Firmware y Software

Para proveer un poco de firmware a los NodeBots y programarlos para jugar un rato pudimos disponer de unos Dev Kits de ElectricImp y usamos el Imp IDE para flashear los modulitos. Esto ultimo, toda una experiencia aparte que hace sonre√≠r al ni√Īo nerd interior que todos tenemos!

Internet of Things

ElectricImp hace muy facil la implementacion de una solucion de IoT. Basicamente permite conectar los modulos (Devices) via WIFI con la nube de ‘Agents’ de ElectricImp. Para esto usamos el Imp IDE para subir las librer√≠as tyrion¬†y imp-io¬†para poder manejar los NodeBots remotamente.

 

ElectricImp Architecture

Sumo

Que puede ser m√°s entretenido de hacer un s√°bado por la tarde que unas luchas de sumo con NodeBots manejados remotamente desde la nube. No hay nada mas que decir, dejo alguna fotos subidas por algunos usuarios a la pagina del Meetup NodeBots

Los nuevos amigos del equipo de SumoBots: Carlos Alberto Mesa Rivillas, Elias Quintero y Alejandro Berrío.

NodeBots Day Medellin - Equipo

Mas para leer

Docker Compose: Creating Multi-Container Applications

Introduction

Simply deploying apps to Docker is not an architectural shift that will bring the agility, isolation and DevOps automated capabilities that a microservices approach can offer. You can always deploy a monolithic application into a Docker container.

The microservice architecture is an approach to decompose a single app as a suite of small independently deployable services communicating with each other.

There should be a bare minimum of centralized management of these services.

What is Docker Compose?

Docker Compose is an orchestration tool that makes spinning up multi-container applications effortless.

With Compose, you define a multi-container application in a single file, then spin your application up in a single command that takes care of everything to get it running.

 

While Compose is not yet considered production-ready, it is great for dev environments, staging, learning and experimenting.

Read More

Global Windows Azure Bootcamp en Argentina

El sábado 29 de Marzo tuvimos la oportunidad de participar en el Global Windows Azure Bootcamp realizado en las oficinas de Microsoft Argentina. En este evento realizado a nivel mundial simultáneamente en más de 138 ciudades del mundo en 57 países se mostraron las características de Microsoft Azure, la solución de cloud computing ofrecida por Microsoft.

Empezamos el evento dando una introducción a Microsoft Azure pasando por todas sus características para luego profundizar en Azure Web Sites. Luego se realizó un ejercicio que se realizaba en todos los lugares donde se desarrolló el evento que consistía en poner en funcionamiento un cloud service que ayudó a procesar datos para encontrar la cura de la diabetes (más información aquí). Con el aporte de Microsoft DPE Argentina, presentamos el nuevo programa para startups Microsoft BizSpark.

GWAB-BA2014

Luego del almuerzo, gentileza de la gente de Microsoft, llego la hora de introducir el concepto de Integración Continua de la mano de TeamCity y Azure Virtual Machines, como así también la opción de realizarlo a través de Visual Studio Online.

Como no podía faltar, contamos en detalle todo lo que ofrece  Azure Storage. Y para cerrar el día hicimos una aplicación desde cero usando Azure Mobile Services que permitia a los usuarios autenticarse con Twitter y Facebook.

También hubo muchos premios incluyendo descuentos para todos los participantes y sorteos de licencias y una Xbox 360.

GWAB-BA2014

Les agradecemos a todos los que participaron del evento e invitamos al p√ļblico en general a descargar las presentaciones que usamos durante el evento en nuestro¬ repositorio de GitHub. Obviamente, algunos temas quedaron fuera del evento. Nos seria de mucha utilidad tu sugerencia para futuros eventos; te invitamos a contactarnos en swevents@southworks.net.

También agradecemos a los oradores que dedicaron su tiempo para la preparación de este evento:

Esperamos que lo hayan disfrutado, muchas gracias

GWAB-BA2014

– El equipo de Southworks

Online Training Courses now available at MSDN

Microsoft’s Training Courses contain free technical training on emerging Microsoft products and technologies: each course includes a set of videos, hands-on labs, and source code samples to get you up-to-speed quickly. These Training Courses, formerly available in Channel 9, are now online at MSDN. This is the first step to converge all technical resources in one standardized well known repository such as the MSDN Learn training site.

The Development Platform Evangelism team (DPE) has done a great job publishing the Offline Training Kits in the form of Online Training Courses during the latest Professional Developers Conference (PDC) in October. With improved tooling, Evangelists can now quickly deliver the latest and greatest course material to users around to world. This allows developers to consume the latest updates in Training Courses online, without having to download the full package updates.

If you access the MSDN library you can start browsing the first three published Courses:

clip_image001

clip_image002

clip_image003

Hope you enjoyed this news and stay tuned for more updates to come!

Search Bundle released!

P&P have been releasing a series of bundles for the last couples of month focused on responsive web applications using AJAX technologies.

This time, the topic of this bundle is the Live Search pattern.

Concept

Searching is a common scenario for most Web Applications.

Usually users performs this task via search pages with results that often span across multiple pages. ASP.NET AJAX can improve the performance and user experience of the search.

Guidance

This bundle includes guidance on

  • Implementing the Live Search pattern using ASP.NET AJAX
  • Displaying progress indicator for long running queries
  • Paging the result to improve search experience
  • Perform server paging to minimize resource usage
  • Implement Submission Throttling pattern using ASP.NET AJAX

Add Live Search capabilities

Download the Search bundle from Codeplex!

You can easily add Live Search features to any existing Web Site.

RealTimeSearchMonitor Control

In this bundle we introduced the RealTimeSearchMonitor control which allows developers to easily incorporate real-time search behavior into their Web applications.

RealSearchMonitorControl

By using the RealTimeSearchMonitor control, developers can declaratively specify in markup code what input controls are to be monitored for user input, without the need to write custom client-side code.

Stay tuned!

Keep on tuned. More releases are coming real soon!

A good day to ship – Validation Bundle released!

¬

The patterns and practices team is shipping a bundle again.

Now, we are providing the community with a guidance bundle focusing in another recurrent concept: The validation bundle.

What are the scenarios addressed by this bundle?

  • Create responsive LOB web applications using an Ajax approach.
  • Improve UI responsiveness of existing web application.
  • Determine what type of validation can be use to address different scenarios.
  • Reuse entity business validation logic.
  • Use Enterprise Library Validation Application Block in an Ajax web application scenario.

Inside this new bundle you can find:

  • Validation QuickStart: source code to demonstrate how to improve UI responsiveness for validation and reuse of validation rules across pages.
  • Validation Application Block from Enterprise Library 3.1: Validation Application Block binary.
  • AJAXControlToolkit.WCSFExtensions.dll: Contains the ServerSideValidationExtender which invokes ASP.NET validators including the Enterprise Library PropertyProxyValidator via AJAX
  • Acceptance Tests: Manual tests that can be executed to walk you through the Quickstart functionality.
  • Documentation: Documentation explaining Validation Guidelines (Security, Schema, and so on) the Quickstart, and how to use the extender.

¬

You can start with Glenn Block's introduction video (15' – 15MB) for a quick introduction to the concepts inside this bundle.

You should stay tuned; there are more bundles to come. (Check the bundles catalog for more guidance)