Today I did some digging through stack overflow and the web and discovered that this functionality is not actually missing it just requires a bit more work.

Details after the break.

Getting IntelliSense working in Visual Studio is as simple as adding a single line of code to the top of your java-script file.

/// <reference path=”/core/scripts/tclib.js” />

This got me thinking even further on how can I namespace all my scripts to prevent collisions between multiple files and also build a core library since I now can rely on IntelliSense in other script files.

I ran across a post on StackOverflow which presented exactly the solution I needed.  Rather than rehash the great explanation there, I am just going to provide the Link.

After several hours of tinkering and researching I finally was able to figure out a solution which works in the normal .NET framework.

There are several pieces that make this work:

First: The WebForm

I wiped out everything no the .aspx page except the declaration that the page existed.

<%@ Page Language=”C#” AutoEventWireup=”true” CodeFile=”TokenGenerator.aspx.cs” Inherits=”TokenGenerator” %>

Second: The Code Behind

On page load we need to wipe out the request and rewrite it so that we are only returning the desired JSON information.  In order for the cross domain information to work we also need to wrap our json with the desired callback method.  In my example I am not accessing any datasource nor am I passing extra query strings but you could using query strings turn a single page into a web service that handles multiple JSON data calls in theory.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class TokenGenerator : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
if (Request.QueryString["callback"] != null)
{
string CallBackSignature = Request.QueryString["callBack"];
string json = CallBackSignature + “({\”name\”:\”Joe\”})”;
Response.Clear();
Response.ContentType = “application/json; charset=utf-8″;
Response.Write(json);
}
}
}

Lastly – The Javascript

Using JQuery to check if the dom is ready we can call our webservice page.

$(document).ready(function () {
GetJSONFromURL(“http://www.somedomain.com/TokenGenerator.aspx?callback=?”, CallBack);
});

function CallBack(response){
// Do Something with the response – which should be your data
}

function GetJSONFromURL(url,success) {
var ud = ‘_’ + +new Date,
script = document.createElement(‘script’),
head = document.getElementsByTagName(‘head’)[0]
|| document.documentElement;

window[ud] = function (data) {
head.removeChild(script);
success && success(data);
};

script.src = url.replace(‘callback=?’, ‘callback=’ + ud);
head.appendChild(script);
}

And whalla you now have a cross domain way to access data via JSON services.

I have a project at work right now where I needed to generate a unique id for an object based on the parent repeaters ItemIndex.

I found this bit of code which worked beautifully

<ItemTemplate>
<%# ((RepeaterItem)Container.Parent.Parent).ItemIndex %>
</ItemTemplate>

I didn’t want to have to write a ton of redundant code for each and every field on the object in a factory pattern. There is literally about 40 to 50 fields on this object.

What I discovered is this cool thing called reflection.

Here is the code snippet:

var name = "PropertyName";
var newValue = "This is my value I want to set";

PropertyInfo prop = obj.GetType().GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
if (null != prop && prop.CanWrite)
{
      prop.SetValue(obj, Convert.ChangeType(newValue, prop.PropertyType), null);
}

Essentially the first two lines here are ensuring that firstly the property exists on the object and secondly that the property is settable.

Since all the properties on my object match up to fields on my datasource, at least the fields I want to translate over do, this works great.

Here is the method I wrote that allows me to pass an XElement with a Generic and iteratively populate all the fields of the object from values nested within the XElement.

private static T BuildByReflection<T>(XElement element) where T : new()
{
   var obj = new T();
   foreach (var subElem in element.Elements())
   {
      var name = subElem.Name.LocalName;
      PropertyInfo prop = obj.GetType().GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
      if (null != prop && prop.CanWrite)
      {
          prop.SetValue(obj, Convert.ChangeType(subElem.Value, prop.PropertyType), null);
      }
   }

   return obj;
}

Up until recently when I wanted to sort a generic list of objects I used the methods I outlined back in June of 2011.

Recently using LINQ I’ve discovered a much more compact code method:

.OrderBy();

Let’s assume we are using our old CoffeeMaker class…

class CoffeeMaker
{

[...]

public int ID;
public string Name;
public decimal Price;

}

And we have a list of CoffeeMakers that we want to sort on the Name.

We simply do the following:

List cMakers = GetCoffeeMakers();
cMakers.OrderBy(cm => cm.Name);

Much shorter for scenarios where you wont be reusing the sort routine frequently and the use doesn’t dictate the neccessity of implementing the full IComparable interface.

var results = (from fc in product
select
new{
FriendlyID = fc.FriendlyID,
Name = fc.ExtendedValue(“Name”),
}).ToList();

This code chunk essentially creates an object which exposes two string parameters: FriendlyID and Name.

The issue arose later when the project requirements necessitated that the results be sorted. I obviously could have simply sorted the list called ‘product’ but I wanted to figure out how to sort the anonymous objects.

results.Sort();

The code above wouldn’t work, since this is a collection of anonymous objects. The compiler simply needs to be told how these objects should be sorted. It can sort simple types such as doubles, strings, integers, etc. It doesn’t know how to sort collections of anonymous types.

C# 3.0 offers a great mechanism for this:

.OrderBy();

Normally you would pass an argument into this such as…

results.OrderBy(sot => sot.SortParameter);

The problem is that we don’t have an object type for anonymous type for which to expose any sort of parameter to sort on.

This is where generics comes to the rescue.

IEnumerable Cast(IEnumerable collection, T type)
{
return collection.Cast();
}

Implementing the above method i can then sort using:

results = Cast(results, new { FriendlyID = “”, Name = “” }).OrderBy(ob => ob.FriendlyID).ToList();

And like magic my anonymous object list is now sorted on the FriendlyID field.

I’ve got an object collection and the objects don’t expose a property which I need to use as a text field.  You have to define these fields by a string so you need to define a custom datasource using your original collection.

IQueryable<Place> places = AppVars.ServiceUtility.ALL<Place>();
DropDownList_NPC_Places.DataSource =
(from Place in places
select new{
Name = Place.Name,
OId = Place.ID.ToString()
}).ToList();
DropDownList_NPC_Places.DataTextField = “Name”;
DropDownList_NPC_Places.DataValueField = “OId”;
DropDownList_NPC_Places.DataBind();

One of the new things that I have been working with at work is the strongly typed generic List<T> this class functions much like an ArrayList except that you’r not forced to guess what is bundled inside.  It wasn’t long though before I encountered a situation where I wanted to sort this list like you do with an ArrayList.  The only problem was that the same sort methods do not work.

Doing some research on the web I ran across some posts that pointed to a really neat method which when implemented looks like this:

List<CoffeeMaker> coffeeMakers = GetCoffeeMakers();
coffeeMakers.Sort(CoffeeMaker.SortByName);

This looks alot like how you sort an arraylist however the way we had been previously doing it at work would result in a sort looking something like this:

ArrayList coffeeMakers= GetCoffeeMakers();

coffeeMakers.Sort(new rootNamespace.subNamespace.Sorts.coffeeMakers());

There are two inherent issues with this first we don’t really know what objects are inside the coffeeMakers ArrayList and secondly our sort is maintained in a separate class file than our actual object.  But really these two objects the sort methods and the class itself are coupled and there is no need to separate them.  It’s also very easy to remember where your sorts are if you could say put them in the class themselves.

Well the Comparison<T> delegate provides a great way to do this.  Here is how we can get the result posted first above and also keep the code in the file.

Let’s build the class above….

class CoffeeMaker
{

[...]

public int ID;
public string Name;
public decimal Price;

}

The first thing we need to do is make the class inherit from the IComparable<T> baseclass.  While we are doing this we need to implement a CompareTo method otherwise we will get a compiler error form inheriting the IComparable class.  We might as well make this sort on the Name.  This is teh method which will be used by default if you call .Sort() without passing any parameters.

class CoffeeMaker : IComparable<CoffeeMaker>
{

[...]

public int ID;
public string Name;
public decimal Price;

[...]

public int CompareTo(CoffeeMaker other)
{

return  this.Name.CompareTo(other.Name);

}

}

Okay thats fine and dandy but how do we sort by other properties how do we make that handy dandy looking sorting in the very first code snippet.  We are going to define static Comparison<T> inside our object class.  See Below.

class CoffeeMaker : IComparable<CoffeeMaker>
{

public static Comparison<CoffeeMaker> SortByID =

delegate(CoffeeMaker cm1, CoffeeMaker c2)
{
return cm1.ID.CompareTo(cm2.ID);
};

[...]

public int ID;
public string Name;
public decimal Price;

[...]

public int CompareTo(CoffeeMaker other)
{

return  this.Name.CompareTo(other.Name);

}

}

This is all still kind of new to me so there may be greater complexity to this than first meets the eye but so far it seems simple its clean and it solves the design problem I have encountered of needing to sort a generic List<T>.

Recently I stumbled across LuaInterface after a fairly steep learning curve I figured out how to work with the data and thought that I would share.

First of all download the files from: http://luaforge.net/frs/?group_id=50

As of this article the current revision was 2.0.3

In the archive you should find two different DLL files which you will need to put in the ‘bin’ folder in your project.

Here is a sample of a class object constructor I used in a recent project using LuaInterface.

// Initialize the Lua Object

var result = lua.DoFile(pathToDataStoreLua);

// Parse all the characters

System.Collections.Specialized.ListDictionary ld = lua.GetTableDict(lua.GetTable(“DataStore_AuctionsDB.global.Characters”));

foreach (DictionaryEntry de in ld)

{

// Do Something

}