Archive for the ‘.net’ Category
WPF’ing around with Boo and external xaml files
Here is a snippet of Boo code (formatted with Python syntax highlighter) that will load a xaml file into a WPF Window:
import System
import System.Windows from PresentationFramework
import System.Windows.Markup from PresentationFramework
import System.IO
class XamlWindow(Window):
def constructor(name):
load_xaml(name)
def load_xaml(name):
xaml_file = File.OpenRead(Path.GetFullPath(name))
self.Content = XamlReader.Load(xaml_file)
Application().Run(XamlWindow("mainui.xaml"))</pre>
See http://devpinoy.org/blogs/smash/archive/2006/10/04/XAMl-meets-Boo.aspx for reference.
Alternatively, here is the equivalent IronPython code:
import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore")
from System.Windows import Window, Application
from System.Windows.Markup import XamlReader
from System.IO import File, Path
class XamlWindow(Window):
def __init__(self, name):
self.load_xaml(name)
def load_xaml(self, name):
xaml_file = File.OpenRead(Path.GetFullPath(name))
self.Content = XamlReader.Load(xaml_file)
Application().Run(XamlWindow("mainui.xaml"))
Lastly, here is an example xaml file
<StackPanel
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Label Content="Hello World" />
<Button Content="Clickable" />
</StackPanel>
VMWare VMDebugger “unable to detect current startup project”
I spent many small packets of time trying to find a solution to this problem over about two months. Luckily, I stumbled across an answer that actually worked for me.
Problem: Visual Studio 2008 with VMWare VMDebugger integration does not work. When I try to launch debugging in a VM, I get a message that says “Unable to detect current startup project”.
Solution: Remove any installer projects that are in the solution.
Source: Read MartinMoesby comment here.
Gestalt = Low-Lying Awesome
Microsoft appears to be betting big on Silverlight. When the Silverlight 1.0 bits were released in 2007, my initial thoughts were, “Yay, Flash for .NET developers.” As Microsoft pushed forward with version 2, version 3, and now version 4 of Silverlight, those sarcastic thoughts have subsided to make way for more genuine curiosity. How did that happen?
Well, for starters, Microsoft delivered real features. Initially, Silverlight demos were all about media (music and video). In addition, Microsoft touted the interopability between dynamic languages like vbx, c#, python, ruby, and javascript. Then, that interopability was sidelined and Silverlight applications started to emerge. Which was interesting. In fact, Silverlight 2 had enough features to stir up debates in the enterprise over which RIA technology was best suited for enterprise applications: Flash 8 with Flex or Silverlight 2. Then, Microsoft played their wildcard. They made Silverlight play nicely with … ugh … Mac OSX. Out-of-browser Silverlight applications made me raise my eyebrows for a technology that I had quickly written off as a “fad”.
That might still be the case. I won’t make a claim either way. But, Silverlight and RIA are spaces where Microsoft continue to innovate. Gestalt is a very good example of that last statement. Gestalt is built atop a foundation consisting of XAML, Silverlight, and dynamic languages. It enables web developers to script their way to rich internet applications in a way that both Flash and Silverlight seemingly missed.
With that said, it is difficult to pinpoint exactly what value Gestalt adds, but you feel it when you’re molding some python, ruby, or javascript hackery into a magical Silverlight-powered application that just works.
The technology appears to still be more of a proof-of-concept than a supported product. But, it makes a strong case for embracing XAML and Silverlight.
Checkout the website and the samples at http://visitmix.com/labs/gestalt/.
Should IronRuby be called NSignificant?
Update: You’re more than welcome to read my angry rant below. However, I felt it would be more responsible if I summed up a few points right here at the very beginning:
- Dynamic languages are awesome for things like web development, scripting, and embedded customization engines for bigger applications.
- IMO, Ruby is more sought after for its web frameworks, scripting/automation (think Rake), and unit testing frameworks than its potential as an embedded language (unlike Python and Lua).
- John Lam’s open source Ruby extension, RubyCLR, enabled CRuby to use .NET types pretty effectively. In other words, I can have a Rails application using .NET code on the server-side if necessary. Or, I could use rspec to unit test my .NET libraries. Both could be done while leveraging the existing Ruby implementation and .NET Framework.
- When John Lam started work on IronRuby, RubyCLR was left to a community that let it fall by the wayside. In the meantime, IronRuby has not been nearly as impressive as IronPython. There, I said it.
Now, feel free to read the original rant below.
Harsh, right? I think so. But, it is time I voice my concerns about the Microsoft’s adaption of the Ruby language. My intent is to put it all out there, and see how the community feels. At the end of the day, my opinion is my own. However, the voice of the community could cause change – of my opinion or otherwise.
What’s beef?
Let me start by saying that I am a .NET developer. I have specialized in Microsoft technologies over my eleven year career thus far. In addition to being a member of our local .NET user group, TriNUG, I am also a member of the local Ruby user group Raleigh.rb. I do not speak for these organizations, but I wanted to point out my involvement with both technical communities.
In addition, my background is web-heavy with a few years of desktop development in there as well. That is to say that Rails was my introduction to the Ruby language. From the perspective of a web developer that dug Javascript before Prototype, JQuery and MooTools, Rails whet my appetite for more Ruby-like development in my paying job. I was amongst the early .NET developers that thought, “Wow, it would be great if we could use a language like Ruby with the CLR!”
In my excitement, I went out and learned about great projects like RubyCLR, John Lam’s old Ruby/CLR bridge, and Ruby.NET, the ruby compiler started by Queensland University of Technology.
Both projects had great merit. The former allows a developer to call .NET assemblies and use .NET types from Ruby (and vice-versa though painful), while the latter aimed to be a full implementation of the Ruby language atop the CLR.
I think those two projects could have adequately fulfilled my dream. More on that later.
Back to my beef. My beef is that Microsoft killed at least one of these projects.
First, they brilliantly (sans sarcasm) hired John Lam, the developer of RubyCLR. That was an excellent decision on Microsoft’s behalf. Initially, I hoped John Lam would continue his work on RubyCLR or a RubyCLR-like project with Microsoft’s resources. Unfortunately, that was not in their plans. Instead, IronRuby was started and RubyCLR died.
Secondly, the Ruby.NET project went seemingly inactive (though Open Source) after IronRuby started gaining steam. It now seems to be stuck at version 0.9 which was working with Ruby 1.8.2.
My beef is that these are two projects the .NET community needs. IronRuby will become more necessary as Microsoft convince us of such. But, IronRuby is seemingly being developed at the expense of two very good projects.
Why RubyCLR and Ruby.NET over IronRuby?
Let’s talk web. As a web developer, my opinion is that dynamic languages are better suited for the web than static languages. In fact, I may be alone in this, I assert Classic ASP with ActiveScripting fits the web development paradigm better than ASP.NET (not including MVC). My assertion is based on the ability to make a change and instantly review it by refreshing the page. This rapid feedback cycle is key to making web development most productive.
Fans of ASP.NET and static languages could make a strong argument for performance. Simply put, dynamic languages do not perform as well as static languages. However, this point is less poignant when talking about the web. Dynamic languages are “good enough” for web development. In fact, bottlenecks in web applications are usually discovered at the point of disk i/o or data access.
Wouldn’t it be great if we could optimize our disk i/o and data access code with a static language, but use a dynamic language like Ruby for the bulk of our web applications? Well, RubyCLR enabled that! If we focus on unidirectional communication be Ruby and .NET – that is Ruby code calling .NET assemblies, we’ll see that RubyCLR is the bees knees! Imagine doing your web development in Rails while being able to call .NET assemblies for things like disk i/o (I can’t imagine replacing Ruby’s ActiveRecord with a .NET ORM).
On the flipside, Ruby.NET was in the process of enabling developers that know and love Ruby to use the .NET Framework and all its libraries in a statically typed manner. This means, not only can I call .NET assemblies from Ruby, but I could write .NET assemblies in Ruby. How awesome is that? (don’t answer)
I believe Microsoft’s most underestimated contribution to developing in Ruby will be easing Rails deployment on IIS. That is the key piece to the puzzle and the metaphoric “milkshake that would bring all the boys to the yard.”
If you don’t have something nice to say…
I’ll end by saying a few good things about IronRuby and Microsoft. As a developer that uses Microsoft’s technologies, I continue to believe that Microsoft will (a) make mistakes and adjust to correct them or (b) continue to be an agent of change that brings the rest of us into the light.
With that said, IronRuby, IronPython, and the DLR are bringing capabilities to .NET development that either didn’t exist before or were a pain in the neck to implement. I haven’t really wrapped my head around doing web development with IronRuby, yet. I hope the experience will be as pleasant as doing web development with Ruby. But, the ability to add scripting to a desktop application utilizing IronPython or IronRuby is very nice.
Now, it’s your turn
I can go on and on about this topic. Those that have had this conversation with me in-person can attest to that. But, I’m really interested in how the community feels. What’s up?
Seven Habits of Highly Effective ASP.NET MVC Developers
This weekend I had the privilege of presenting two talks at the CMAP Code Camp in Central Maryland. I gave a talk on the Spark View Engine and a new talk called “Seven Habits of Highly Effective ASP.NET MVC Developers.”
Here are the slides for the latter talk:
Richmond Code Camp 2009.2
Wow! What an event!
This weekend, I joined ~400 others for the Richmond Code Camp and a good time was had. As others have noted, the hardest part of the day was choosing which talks to attend due to a schedule full of excellent topics and speakers.
I started off with Justin Etheredge’s talk on Linq Expressions. This was 75 minutes of great slides and polished demos of basic to advanced Linq concepts. I left that talk more educated and less scared of the power of Linq Expressions. Justin has an unbelievable understanding of how Linq works and an amazing ability to convey that to the layman with nothing more than a stock photo of a cat and a VM with Win 7 and VS 2010.
Second, I attended a talk that was missed from Raleigh’s Code Camp two weeks earlier. I went to John Feminella’s talk on Ruby for C# developers. John gave .NET developers a great introduction to the Ruby language using IronRuby (I thought that was brave at this point). To my surprise, John held up his end with great content and examples, and IronRuby held up its end with stability and support for most of the features of Matz Ruby (the original implementation of Ruby).
Next, I decided to checkout Open Spaces. The evening before, I jokingly suggested that the audience would convince Kevin Hazzard to present something on the DLR at Open Spaces since he was not officially presenting. Well, I guess they did! Kevin led a discussion on IronPython and the DLR that included some very nice demos. He also discussed C# 4.0’s new “Dynamic” type and how it actually works. I gained a lot of insight on when and where the DLR and Dynamic Languages on .NET are useful. And, while I love Ruby, IronPython is making the Python language very attractive to me.
Another talk that I was able to attend was by Chris Love. He talked about building quality ASP.NET applications faster. I know Chris to be a very experienced developer. He just completed an updated version of a book I found to be very practical when I was getting into more advanced ASP.NET concepts, ASP.NET 3.5 Website Programming: Problem – Design – Solution. His talk drew off of his experiences building applications and sites for his clients. He talked about architecture as well as development practices. I recommend his talk to anyone doing ASP.NET development that is looking for practical advice on how to manage it all from start to finish.
In the last time slot of the day, I presented Spark, an ASP.NET MVC View Engine, to a great audience. This was essentially the same talk that I gave a couple of weeks earlier at Raleigh’s Code Camp, but I made some modifications for the Richmond crowd. Here are the slides from that talk:
Enjoy!
Rails-like ASP.NET Development Assets
Here are the slides:
*Note: Sqlite ADO.NET Provider is required to run this code. You can get it from http://sqlite.phxsoftware.com/
Debug an IE Add-On in Visual Studio 2008
I’m working on a project that involves creating an IE Add-On in C#. It is an inherited project that was created in Visual Studio 2005 targeting the .NET Framework 2.0.
Well, times have changed. I am now doing most of my development in Visual Studio 2008, and (when lucky) I am using the features of the .NET Framework 3.0 or higher. When I first made the switch, I tried to use 2008 to continue my work on the toolbar, but I failed miserably. I was shocked to find out that my process of registering my assembly in a post-build action and launching IE as a Start Action did not work in 2008. At the time, I quickly got over it, and preserved 2005 just for that project.
Luckily, in a more recent attempt to use 2008 for this type of development, I was able to solve the problem. Check it out.
Problem:
Whenever I tried to debug my IE Toolbar project in Visual Studio 2008, I would get a nasty exception that says, “Error while trying to run project. Unable to start debugging”
My project is configured to register the assembly using regasm in a Post-build step. Then, as you can see below, the VS Debugger is configured to start Internet Explorer (and subsequently attach to the process).
Well, that was the wrong way of doing it. I was able to get it to work successfully by modifying the Start Action like such:
And it worked!
UPDATE: I still had issues on a separate computer. Adding “about:blank” to the command line arguments fixed the issue.
Handling mscorlib.dll System.Threading.ThreadAbortException issue in an ASP.NET application
I discovered an unhandled System.Threading.ThreadAbortException was being thrown in my ASP.NET application. I was only able to see this issue when running the application in the Visual Studio debugger. The offending code was a seemingly trivial call to Response.Redirect.
When I called Response.Redirect, the thread handling the current response would be aborted. The thread didn’t like being aborted out of the blue like that. The fix is to pass the second parameter to the Response.Redirect method which tells Response.Redirect whether or not it should end the response. Passing in false will cause the Redirect method to fire, but allow the original response thread to execute the code after the call to Response.Redirect. I use a Return statement to avoid unnecessary processing.
Microsoft explains it here: http://support.microsoft.com/default.aspx?scid=kb;en-us;312629
Improve page load performance in your ASP.NET MVC site
As ASP.NET MVC become more popular in the enterprise and behind high-traffic commercial web sites (like Dimecasts.net), developers will look for ways to increase performance.
One well known way to increase performance of any website is to combine files to minimize HTTP requests (see Yahoo! Performance Rules). The reason is that most modern browsers use two threads to load a given page and all of its assets (css, js, images, etc.). This post will give a quick walk-through of an ASP.NET MVC implementation of a CSS consolidator.
In typical MVC fashion, I will give a quick breakdown of the model, the view, and the controller.
Let’s start with the controller.
My controller has one need: it provides a pretty url for me to point my tag to retrieve passed-in stylesheets. I implemented a controller called StaticController and gave it an action called CSS. Here is a snapshot of the action:
public ActionResult CSS(string id)
{
if (String.IsNullOrEmpty(id)) return View();
string[] filenames = id.Split(',');
string path = HttpContext.Request.ServerVariables["APPL_PHYSICAL_PATH"];
path = String.Concat(path, @"Content\"); // path to css files
string cssData = Models.StaticCSS.GetContent(filenames, path);
ViewData["css"] = cssData;
return View();
}
Quick explanation of the above code:
The action uses the default MVC routes (for simplicity). So, the id parameter is used to pass a comma-delimited string of stylesheet names. The path to the Content directory (the default folder for stylesheets) is derived, combined with each file name in the id parameter and passed to the model.
Let’s see how our model works.
The model is named StaticCSS and here are the methods:
public static string GetContent(string[] filenames, string cssDir)
{
StringBuilder sb = new StringBuilder();
if (filenames.Length == 0 || String.IsNullOrEmpty(cssDir))
return String.Empty;
foreach (string f in filenames)
{
string filepath = (f.EndsWith(".css")) ?
String.Concat(cssDir, f) : String.Concat(cssDir, f, ".css");
sb.Append(@"/* Start CSS file */");
sb.Append(Environment.NewLine);
sb.Append(GetFileContents(filepath));
sb.Append(@"/* End CSS file */");
sb.Append(Environment.NewLine);
}
return sb.ToString();
}
public static string GetFileContents(string file)
{
try
{
using (TextReader textReader = new StreamReader(file))
{
return textReader.ReadToEnd();
}
}
catch(FileNotFoundException)
{
}
return String.Empty;
}
Quick explanation:
The public static method, GetContent loops through a list of files, combines their contents into a string, and return the string. The GetFileContents method opens the file and returns the contents.
If we look back at the remaining code in our action:
ViewData["css"] = cssData;
return View();
We are adding the css file contents to the ViewData hash and calling the view.
Here are the important parts of the view:
<%
Response.ContentType = "text/css";
Response.ContentEncoding = Encoding.UTF8;
Response.Write( Server.HtmlDecode(ViewData["css"].ToString()) );
%>
We are setting the content-type to “text/css”, which is important in standard-compliant browsers (not IE). We’re setting the encoding dumping the content to the page. These three lines essentially turn the view into a standard css file.
Finally, to use this code I would simply add the following line to any view requiring css files:
<link href="/Static/CSS/cssfile1,cssfile2,cssfile3" rel="stylesheet" />
This would download cssfile1, cssfile2, and cssfile3 in one HTTP request instead of three.
This is a simplistic approach that doesn’t care (yet) about the amount of memory used to load very large css files. But, if you choose to follow this model, I would love to hear how it performs for you.
Professional Programmer Notes 