Using multi column forms in Enrich is a request I hear sometimes because some feel that there’s too much white space on screens. This study makes a good argument that we should avoid doing so.

Download the release from NuGet.

Here’s a simple way to administer the group of servers sort of like a Single instruction, multiple data (SIMD) system using freely available tools.

First download Mark Russinovich’s, PsExec which lets you run commands on remote systems:

PsExec is a light-weight telnet-replacement that lets you execute processes on other systems, complete with full interactivity for console applications, without having to manually install client software.

This utility will let you forward a command to a remote system for execution and is the foundation of this technique.  The fact that this tool doesn’t require an install on the environments makes setup a breeze. However, you may need to make a few security/firewall changes on each system to get it the communication between systems to work.

Next, I’ve devised a simple batch file (VMs-cmd.bat) that I can pass a command to that will then be executed in sequence on every server in the environment. For example, the following command will create the c:\whatever directory on every server:

VMs-cmd "mkdir c:\whatever"

Here’s the source code for VMs-cmd.bat:

SET VMs=01, 02, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14
FOR %%t in (%VMs%) DO (PsExec.exe \\YouServer-%%t -u username -p password c:\windows\system32\cmd.exe /C %1)

Note that:

• This assumes a naming convention of YourServer-XX where XX is the server number. Update the code with your server naming convention and numbers.
• You will need to replace the username and password in the batch file

Since .Net 2.0 there are two main kinds of garbage collectors used by the CLR:

1)      Server – Optimized for long running applications that will be the primary software on a system. Memory is allocated more aggressively to the .NET memory heaps causing more memory is used overall by the application but with the hope of faster performance.   Recommended by Microsoft to be used on multi-processor systems and it appears to be on by default on those systems.

2)      Workstation – Optimized for applications that will be running alongside many other processes. Memory is allocated more conservatively at the possible expense of more time being spent in the GC.

Btw, you can determine which GC is being used by checking the GCSettings.IsServerGC property.

The GC can be changed via the aspnet.config file under C:\Windows\Microsoft.NET. Note that this setting affects ALL ASP.Net applications on the server:

<configuration>
    <runtime>
        <gcServer enabled="false" />
    </runtime>
</configuration>

While testing this setting the effect of the different GC’s under ASP.Net I’ve noticed that the Workstation GC requires around 65-75% of the memory required for the Server GC. This is very good news for those of us trying to have an economical shared hosted environment (ie, trying to host as many application instances on a single server as possible).

Here is the specific data collected from the test for the two different garbage collectors showing the difference before and after the aspnet.config change:

The basic strategy to follow is:

1. Use the application
2. Force Garbage Collection
3. Using WinDbg inspect the application’s memory, looking for objects of a certain type should have been collected
4. If objects are found, determine what references to them is preventing collection.
5. Fix the problem
6. Repeat as needed

Without WinDbg, or a similar tool, there would be much guesswork or application instrumentation to locate leaked objects.

Here are the detailed instructions:

1. Restart the application
2. Exercise the functionality to test for memory leaks. Be sure to repeat actions several times to magnify the results.
3. Force the garbage collector to run (GC.Collect() and GC.Collect(gen, GCCollectionMode.Forced)). The GC is non-deterministic so you should do this a few times until you notice memory for the process is no longer changing in Task Manager.
4. Attach to the application process in WinDbg. If you’re debugging an ASP.Net web application attach to w3wp.exe.

   

5. Next, load the .Net debugging extensions by entering the following command (the command entry is at the very bottom of the screen)
   

    

   .loadby sos mscorwks
   

6. Get a list of uncollected objects. Replace <TypeName> with the name of a class that you would expect to not be loaded in memory. In the example below: VC3.TestView.Business.Student.

    

   !dumpheap -type <TypeName>
   

   The command will list the memory address objects of that type that have not yet been garbage collected, followed by some statistics on the objects. You’ll need to cross reference the type name (MT) in the Statistics section with objects in the heap to locate the address of a single object.

    

   

    

7. Now, use WinDbg which will tell you what GC rooted reference is keeping the object alive

    

   !gcroot -nostacks <ObjectAddress>
   

   

Luckily the classes ExoWeb generates for your entities will likely seem quite familar to you. ExoWeb lets you write JavaScript like this (contrived example):

// prompt for the person's new name

myPerson.set_Name(window.prompt("Edit Name", p.get_Name()));

// insert a new dog as a pet

myPerson.set_Pet(new Dog({Name: "Fido", Weight: "20"}));

// save the changes on the server

window.context.server.save(myPerson);

We’ve done our best to make sure the parts and pieces that comprise the ExoWeb entity system work consistently, fit together cleanly and take advantage of JavaScript’s language features. Here is a short overview of the essential concepts as to how ExoWeb entity classes and objects work (after they have been loaded on the client — more on that another day):

Classes

Client-class per server-class – There’s one JavaScript class generated by ExoWeb for each class in your server-side object model. Classes can be selectively loaded for efficency so only the classes you need are sent to the client.

JavaScript friendly – Each entity class comes with all of the standard benefits of javascript classes so new, instanceof, prototypes and inheritance all work as expected:  new Person() instanceof Person == true.

Inheritance – Classes support single inheritance implemented via JavaScript prototyping. All generated entity classes ultimately derive from ExoWeb.Model.Entity.

Object Identity, Construction and Pooling

Object ids – Every instance, including yet to be persisted ones, have a single string identifier associated with it.  If server-side objects have non-string ids (such as numbers, guides, or multipart ids) they will be converted to a string representation for use in the client object model.

Every instance has a unique id – No two instances can share the same ID. Period.

Equals (==) works – new Person(1) == new Person(1).

New objects have ids too, and they may change – A client-only id is assigned to new, yet to be persisted, objects. If the object is later persisted and an ID is assigned server-side, ExoWeb will reflect the new id on the client but keep the temporary one around behind the scenes so that they are both valid references.

Objects are created via their constructor – This works as you’d expect. If the object already exists server-side, pass its ID into the constructor: new Person(); or, new Person(1).  There are also some shortcut constructors to combine construction and property (see the pet example at the beginning of this post).

Objects are pooled – ExoWeb tracks objects in an object pool.  Object construction queries and updates the pool as needed.  Invoking the same constructor with the same ID twice will result in a single object being created (new Person(1) === new Person(1))

Pooling works with inheritance – Subclass instances appear in their base class’ pools. new Dog(32) === Animal.meta.get(32)

Object Properties and Methods

Objects have properties – The properties are generated based on the server-side object model.

Objects have methods – Methods are generated based on the server-side object model and cause a server roundtrip to occur when invokved.  Client-only methods can also be defined.

Property getters/setters – Properties are accessed via getters and setters:  myObj.set_FirstName(“George”); myObj.get_FirstName().  This may seem annoying, and should be familar to Java developers, but is required so that eventing, validation and rules will work.

Properties are typed – Each property is of a specific type and both either entity types or javascript intrinsic types are supported. If a property’s value is set to the wrong type and exception is thrown and the value is discarded.

Property change eventing – Events are raised when properties change which can trigger UI updates.  Changes are tracked behind the scenes by ExoWeb so they can be persisted later.

Property validation – Properties are validated based on metadata provided by your ORM. Validation events can be used to drive validation presentation in the UI.  Checkout the jQuery plugin we’ve put together that makes this easy.

Client-only properties – Properties can be declared in JavaScript on the client to help simplify certain UI tasks.  Checkout the $extend() function for more details.

Calculated properties – Properties can have calculated values.  ExoWeb automatically recalculates the property when one of its dependencies change. Like other all properties, a change events are raised so the UI can reflect the changes.

Metadata

Class metadata – Information about each entity type, such as properties, are available client-side through the type’s meta property:  Person.meta

Object metadata – Each object has metadata, such as its identity and type metadata, accessible via its meta object:  myObj.meta

Conditions metadata – Information calculated about the current state of each object are tracked as object conditions.  This includes things like validation errors and basic security checks. This concept was taken directly from ExoRule, our open source rules engine.

At VC3 we’ve solved this problem for our own automated UI tests and I’m happy to announce we’ve released the code as free, open source software: Amnesia.

With Amnesia the setup and tear down of automated UI tests is easy and very fast. Amnesia uses distributed transactions and forces all requests made to the web app under test to participate in a database transaction so all work can be rolled back at the end of each test.

Please check out the project site for more information and to download the code: http://amnesia.codeplex.com.

Thanks to Graeme Hill (High performance database rollback in automated tests with SQL Server) for the concept.

Usage:

checkboxes.checkAll(allSelector)

where:

• checkboxes –  jQuery object for the set of checkboxes to control
• allSelector – CSS selector string to match the “select all” checkbox

Example:

<input id="all" type="checkbox" name="all"></input>Select All<br />

<div id="myCheckBoxes">

<input type="checkbox" name="1"></input>1<br />

<input type="checkbox" name="2"></input>2<br />
<input type="checkbox" name="3"></input>3

</div>

<script type="text/javascript">

$(function() {
$("#myCheckBoxes input").checkAll("#all");
});

</script>

Plug-In Code:

;(function($) {
	$.fn.checkAll = function checkAll(allSelector) {
		var all = $(allSelector);
		var items = this;

		all.click(function() {
			if (all.get(0).checked)
				items.attr("checked", "checked");
			else
				items.removeAttr("checked");
		});

		function evalAllChecked() {
			if (items.filter(":checked").length == items.length)
				all.attr("checked", "checked");
			else
				all.removeAttr("checked");
		}

		evalAllChecked();
		items.click(evalAllChecked);
	}
})(jQuery);

When: Weds 9/30, 6:00 PM

Where: Richland County Public Library – Bostick Auditorium