The original developers of the modules used ApacheFop.Net for the PDF generation for all reports.

Step 0:

First I had to install the J# redistributable.

Step 1:

After doing that I moved over assembly entries from the 4.3 web config:

<assemblies>
    <add assembly="vjscor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A" />
    <add assembly="vjslib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A" />
</assemblies>

Step 2:

This got close.  Now when trying to generate a report I got the following error:

Could not load file or assembly ‘vjscor, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a’ or one of its dependencies.

Okay, well, then let’s use a binding redirect in the assembly binding section of the runtime of the web.config.  I’m not sure why it was trying to load 1.0.5000.0 when I told it to load 2.0.0.0, but we’ll correct that:

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <probing privatePath="bin;bin\HttpModules;bin\Providers;bin\Modules;bin\Support;"/>
        <dependentAssembly>
            <assemblyIdentity name="vjslib" publicKeyToken="b03f5f7f11d50a3a"/>
            <bindingRedirect oldVersion="1.0.0.0-1.0.5000.0" newVersion="2.0.0.0"/>
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="vjsnativ" publicKeyToken="b03f5f7f11d50a3a"/>
            <bindingRedirect oldVersion="1.0.0.0-1.0.5000.0" newVersion="2.0.0.0"/>
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="vjscor" publicKeyToken="b03f5f7f11d50a3a"/>
            <bindingRedirect oldVersion="1.0.0.0-1.0.5000.0" newVersion="2.0.0.0"/>
        </dependentAssembly>
    </assemblyBinding>
</runtime>

Step 3:

One step closer.  Now I get the error:

A critical error has occurred.The type initializer for ‘java.lang.System’ threw an exception.

Well, at least it looks like it’s trying to load the J# libraries.

Finally after much googling around I finally hit upon the last step in the enigma at

http://blogs.windwardreports.com/davidt/2011/02/calling-j-code-from-net-40.html

I added to my Default.aspx the external call for manually loading libraries:

//used for loading J# libraries
[DllImport("kernel32", SetLastError = true)]
static extern IntPtr LoadLibrary(string lpFileName);

and then to the OnInit I added:

//load needed J# libraries
if (Environment.Version.Major >= 4)
{
    string folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), @"..\Microsoft.NET\Framework\v2.0.50727");
    folder = Path.GetFullPath(folder);
    LoadLibrary(Path.Combine(folder, "vjsnativ.dll"));
    LoadLibrary(Path.Combine(folder, "vjscor.dll"));
    LoadLibrary(Path.Combine(folder, "vjslib.dll"));
}

I tried removing each step and the only step that you can do without is step one since we’re manually loading the libraries manually anyways.  Oddly, even though I’m now manually loading the libraries, I still need to do step two. Oh well, this is what works for me but as always YMMV.

Thanks,
Brian

I think it escapes a lot of C# devs that they have the same pointer abilities as C/C++, or maybe it’s that those features have been intentionally down-played by Microsoft for a reason. As C# devs we’ve come to rely on nice, safe and managed code and GC. That doesn’t mean we can’t cause an out of memory exception or infinite recursion or some other bad thing along the way, but for the most part C# tries to protect us. While I’m not going to cover pointers (something of which I have a fondness for given that my very first college class was “Fundamentals of C”) I do want to go over the fixed() operation.

Fixed is basically telling the GC, “Don’t move me, don’t touch me, don’t GC me, don’t even look at me” which is why fixed can only be used within an unsafe context. It’s important to mention that unsafe means, um, unsafe. When you identify an area of code as unsafe you’re saying, “Hey, I know I’m doing something that could potientially be really bad and all the work MS has done to try and protect me I’m ignoring. I really, really promise to only use smart code here.”

Here’s a bit of code using fixed:

unsafe void FixedExample()
{
    double[] arr = { 0, 1.5, 3, 4.5, 6, 7.5, 9 };
    fixed(double* p1 = &arr[1])
    {
        fixed (double* p2 = &arr[5])
        {
            int diff = (int)(p2 - p1);
            Debug.Print(diff.ToString());
        }
    }
}

unsafe void FixedExample2()
{
    double[] array =  { 0, 1.5, 3, 4.5, 6, 7.5, 9 };
    fixed (double* arr = array)
    {
        double* p1 = &arr[1];
        double* p2 = &arr[3];
        int diff = (int)(p2 - p1);
        Debug.Print(diff.ToString());
    }
}

Basically, fixed allows you to get pointers to managed types which would otherwise be subjected to GC. If you were to work just with pointers and not managed types you can do the above (using stackalloc) without even needing fixed.

unsafe void StackallocExample()
{
    int arraySize = 7;
    double* arr = stackalloc double[arraySize];
    double j = 0;
    for (int i = 0; i < arraySize; i++, j += 1.5)
    {
        arr[i] = j;
    }

    double* p1 = &arr[1];
    double* p2 = &arr[15];
    int diff = (int)(p2 - p1);
    Debug.Print(diff.ToString());
}

but of course the above code is very bad. If you didn't notice, the second pointer points to the 16th element (since we're obviously 0 based) but I only allocated 7 doubles worth of memory. If I were do try and do something with arr[15] (rather then just determine the distance between the two elements) that would be very bad as it wouldn't represent a value I had intended and would just be some random bit of whatever was stored in that memory location. Interestingly enough, if you try the same in the first two examples you'll get a runtime exception.

Thanks,
Brian

Recently I was tasked with optimizing a large code base to utilize the TPL. The first problem? List and Dictionary aren’t thread safe. That’s right, two of the most common data structures aren’t thread safe. Fortunately we’ve been provided with alternatives that are thread safe in the System.Collections.Concurrent Namespace.

The biggest difference I’ve seen between using List and using one of the alternatives, ConcurrentBag is that you can’t access items in a ConcurrentBag via an indexer. The truth, however, is that alternative methods are provided via LINQ extension methods.

Consider:

ConcurrentBag<int> myBag = new ConcurrentBag<int>();

var task1 = Task.Factory.StartNew(() =>
    {
        LongRunningMethod();
        myBag.Add(1);
    });

var task2 = Task.Factory.StartNew(() =>
    {
        LongRunningMethod();
        myBag.Add(2);
    });

var task3 = Task.Factory.StartNew(() =>
    {
        LongRunningMethod();
        myBag.Add(3);
    });

Task.WaitAll(task1, task2, task3);
Parallel.For(0, myBag.Count, i =>
{
    Debug.Print(myBag.ElementAt(i).ToString());
});

List<int> myList = new List<int>();
LongRunningMethod();
myList.Add(1);
LongRunningMethod();
myList.Add(2);
LongRunningMethod();
myList.Add(3);
for (int i = 0; i < myList.Count; i++)
{
    Debug.Print(myList[i].ToString());
}

resulted in the output:

1
3
2
1
2
3

with, obviously, the parallel methods being faster.

The other problem we ran into is manipulation of visuals. As I’m sure you know manipulation of visuals is required to be on the main thread. Otherwise you start getting all sorts of permission issues. The minute you start having to move doing things on the main thread you lose the advantages you gained by moving towards all this parallelism. Future projects will move towards the MVVM pattern but past projects we’ll have to work on what we can.

Use ToUpperInvariant rather than ToLowerInvariant when normalizing strings for comparison.

Sure enough if you go to the Microsoft page on it, it says

Use the String.ToUpperInvariant method instead of the String.ToLowerInvariant method when you normalize strings for comparison

Not wanting to blindly trust “Teh MAN” I threw together a quick testbed for testing many of the variants on doing string comparisons.

Here are the results (running 1 million comparisons) comparing
Guid.NewGuid().ToString() to “Now is the time for all good men to come to the aid of their country.”:

If you read through Microsoft’s whole article you’ll see for case-insensitive ordinal comparisons they recommend

String.Compare(strA, strB, StringComparison.OrdinalIgnoreCase)

As you can see in the results this is borne out. It’s not inconceivable that these results could be significant, especially when doing a significant number of string comparisons.

The problem arises when I change what’s being compared to a string that is almost identical to the original.

Here are the results (running 1 million comparisons) comparing
“Now is the time for all good men to come to the aid of their countrt.” to
“Now is the time for all good men to come to the aid of their country.”:

In both cases I ran the test (with code below this) several times and each time it gave similar results.

So what does this all mean? If you’re only doing a few thousand comparisons where case is an issue I wouldn’t worry about anything and just keep doing what you’re doing.
Other then that I can only recommend staying with Microsoft’s suggestion. While there was significant differences between the results, in general Microsoft’s suggestion would be more applicable without some sort of explicit knowledge of the data. I think if you’re going to analyze much beyond this you risk attempting to over-optimize.

Thanks,
Brian

string myStringToCompare = "Now is the time for all good men to come to the aid of their countrt.";// Guid.NewGuid().ToString();
string originalString = "Now is the time for all good men to come to the aid of their country.";
string results = "";

Stopwatch watch = new Stopwatch();

int numComparisons = 1000000;
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (myStringToCompare == originalString) { }
}
watch.Stop();
results += "equals operator:" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (myStringToCompare.Equals(originalString)) { }
}
watch.Stop();
results += "\nequals method:" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.CompareOrdinal(myStringToCompare.ToUpper(), originalString.ToUpper()) == 0) { }
}
watch.Stop();
results += "\nCompareOrdinal(ToUpper):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.CompareOrdinal(myStringToCompare.ToUpperInvariant(), originalString.ToUpperInvariant()) == 0) { }
}
watch.Stop();
results += "\nCompareOrdinal(ToUpperInvariant):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.CompareOrdinal(myStringToCompare.ToLower(), originalString.ToLower()) == 0) { }
}
watch.Stop();
results += "\nCompareOrdinal(ToLower):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.CompareOrdinal(myStringToCompare.ToLowerInvariant(), originalString.ToLowerInvariant()) == 0) { }
}
watch.Stop();
results += "\nCompareOrdinal(ToLowerInvariant):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.Compare(myStringToCompare, originalString, StringComparison.OrdinalIgnoreCase) == 0) { }
}
watch.Stop();
results += "\nCompare(OrdinalIgnoreCase):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.Compare(myStringToCompare, originalString, StringComparison.InvariantCultureIgnoreCase) == 0) { }
}
watch.Stop();
results += "\nCompare(InvariantCultureIgnoreCase):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.Compare(myStringToCompare, originalString, StringComparison.CurrentCultureIgnoreCase) == 0) { }
}
watch.Stop();
results += "\nCompare(CurrentCultureIgnoreCase):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.Compare(myStringToCompare.ToUpperInvariant(), originalString.ToUpperInvariant(), StringComparison.Ordinal) == 0) { }
}
watch.Stop();
results += "\nCompare(ToUpperInvariant, Ordinal):" + (watch.ElapsedMilliseconds) + " milliseconds";

watch.Reset();
watch.Start();
for (int i = 0; i < numComparisons; i++)
{
    if (string.Compare(myStringToCompare.ToLowerInvariant(), originalString.ToLowerInvariant(), StringComparison.Ordinal) == 0) { }
}
watch.Stop();
results += "\nCompare(ToLowerInvariant, Ordinal):" + (watch.ElapsedMilliseconds) + " milliseconds";

txtResults.Text = results;

The first problem relates to merged dictionaries within a dictionary. In our project we have a master dictionary in a common project. All other projects call this common project. The common project contains only the xaml resource dictionaries. Our main dictionary looks kind of like:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    >
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="ComboBoxStyle.xaml"></ResourceDictionary>
        <ResourceDictionary Source="ButtonStyle.xaml"></ResourceDictionary>
   </ResourceDictionary.MergedDictionaries>
</ResourceDictionary>

Virtually every element in our application is styled via this dictionary. This creates a clean set of styles in seperate files that makes maintenance of these really simple. The problem is that in .net 4.0 none of the styles in these dictionaries were being applied. It seemed like .net 4.0 just wouldn’t go down into the resource dictionaries and get the proper styles. After posting a question in the msdn forums I took a look around Connect (Microsoft’s listing of bugs) and found that someone else had the same problem.

Fortunately one of the MSDN moderators came to my rescue and posted a workaround. Oddly enough all you have to do is include an empty style after the merged dictionary and everything starts working again. Our new master resource dictionary looks something like:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    >
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="ComboBoxStyle.xaml"></ResourceDictionary>
        <ResourceDictionary Source="ButtonStyle.xaml"></ResourceDictionary>
   </ResourceDictionary.MergedDictionaries>
   <Style TargetType="{x:Type Window}"/>
</ResourceDictionary>

and now all cascading styles are being applied correctly.

The second problem has to do resizing and scaling of images. Once again I started with a post on MSDN forums and then went and took a look around connect (I really should begin starting at Connect). It seems that in .net 4.0 in order to increase the effeciency of everything they changed the default rendering of images from Fant (extremely high quality) to Low quality. Not finding any easy solutions I simply changed our master resource dictionary from as show above to:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    >
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="ComboBoxStyle.xaml"></ResourceDictionary>
        <ResourceDictionary Source="ButtonStyle.xaml"></ResourceDictionary>
   </ResourceDictionary.MergedDictionaries>
   <Style TargetType="{x:Type Window}"/>
       <!--Fix for images rendering in low quality-->
   <Style TargetType="{x:Type Image}">
      <Setter Property="RenderOptions.BitmapScalingMode" Value="HighQuality"/>
   </Style>
</ResourceDictionary>

so that images would always defualt to rendering in High Quality. After I created this solution someone posted as a workaround in Connect just to add:

RenderOptions.SetBitmapScalingMode(this, BitmapScalingMode.HighQuality);

to the constructor of your main window and this will inherit to all images by default. I haven’t tried this solution and I’m not sure what would happen if you have projects other than the main project that open their own windows. It would seem like this should be a global setting since you’re setting the static in RenderOptions and this should work fine. For us this was unneeded since every window in all our projects calls the xaml shown above.

Well, if we run into anything else I’ll post it here but these were the only two issues we’ve found so far. It’s been a big benefit to upgrade for us to .net 4.0 if for no other reason then to have Parallel.For and Parallel.ForEach.

Thanks,
Brian

See
http://monotouch.net/

For those of us with an Android phone, Mono is running in Android, it’s just not very stable.  Here is a post of one of the Mono developers that compiled the Mono libraries from his Android from a debian install on his SD card.  Yes, in Android he’s running debian to compile Mono.  Is that not just sweet nerdy goodness?  While there is no time line for a full stable release of Mono on Android it’s in active development and, unlike the iPhone/MonoTouch option, it probably won’t cost a thing once it gets stable.

So what does this mean for us doing smart phone development?  When I was in college I applied for and received a grant for a platform agnostic project, written in java, to do streaming media, web cam and audio between multiple PCs.  For the first month of the project I developed on linux (don’t remember the branch) with Java.  I moved all the code to Windows and came across serious threading issues.  I fixed all those and spent the next month developing in Windows.  After that second month I moved everything back to linux and ran across serious threading issues.  For the last month of the project I compiled to a shared directory and tested on both linux and Windows.  I highly doubt there will ever be a stable environment that will work for all platforms, hardware is just too different.  MonoTouch has specific interfaces to the iPhone APIs.  Once Mono for Android gets stable I’m sure there are going to be wrappers for the Java APIs for Android.  But is this a bad thing?  Isn’t competition good?

Later,
Brian

Software Engineering Code of Ethics and Professional Practice (Short Version)

PREAMBLE

The short version of the code summarizes aspirations at a high level of the abstraction; the clauses that are included in the full version give examples and details of how these aspirations change the way we act as software engineering professionals. Without the aspirations, the details can become legalistic and tedious; without the details, the aspirations can become high sounding but empty; together, the aspirations and the details form a cohesive code.

Software engineers shall commit themselves to making the analysis, specification, design, development, testing and maintenance of software a beneficial and respected profession. In accordance with their commitment to the health, safety and welfare of the public, software engineers shall adhere to the following Eight Principles:

1. PUBLIC – Software engineers shall act consistently with the public interest.

2. CLIENT AND EMPLOYER – Software engineers shall act in a manner that is in the best interests of their client and employer consistent with the public interest.

3. PRODUCT – Software engineers shall ensure that their products and related modifications meet the highest professional standards possible.

4. JUDGMENT – Software engineers shall maintain integrity and independence in their professional judgment.

5. MANAGEMENT – Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance.

6. PROFESSION – Software engineers shall advance the integrity and reputation of the profession consistent with the public interest.

7. COLLEAGUES – Software engineers shall be fair to and supportive of their colleagues.

8. SELF – Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession.

This Code may be published without permission as long as it is not changed in any way and it carries the copyright notice. Copyright (c) 1999 by the Association for Computing Machinery, Inc. and the Institute for Electrical and Electronics Engineers, Inc.

Thanks,
Brian

Until then here is a bit of xaml for self-referencing bindings.

<TextBlock
  Grid.Column="1"
  Width="75"
  Foreground="{StaticResource ActiveTabForeground}"
  TextWrapping="NoWrap"
  TextTrimming="CharacterEllipsis"
  ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Text}"
  Name="txtHeader"/>

As you can see I often use these with TextBlocks where I’m using text trimming. The reason being that, with text trimming, the text gets cut short if it exceeds the width of the textblock. This way users will be able to mouse over the textblock and get the tooltip containing the full value.

Where else would this be useful? Well, um, I don’t know since I only use this with tooltips on TextBlocks. But it is certainly helpful for that.

Enjoy,
Brian

(I love kicking it ol’school and using tables)

To the 26% that said no I say, “Good, you’re doing your job.” To the rest of you, “Get to work.”

I don’t often write opinion pieces preferring to keep the focus of this blog more on tutorial type posts, maybe because I don’t really consider myself any real authority. I do my job and in the course of my job I learn a lot that I want to pass on to other people.

So why start now? Well, this survey struck a nerve for me. Maybe it’s because this has some fingers in my post about Oracle and Java. In that post I reveled in the fact that Microsoft is able to keep the .Net framework moving forward at a fast pace and that, relative to .Net, Java has become fairly stagnant.

In Jeff Atwood’s post, The Two Types of Programmers he discusses the two types of programmers as mentioned in an article by Ben Collins-Sussman which says there are two classes of programmers, the “20%” and the “80%” programmers.

To this I have a serious problem. I spend a great deal of time reading the latest programming books, blogs and magazines. I do so because I want to stay current in my field. If I was doctor it would be expected that I would stay up-to-date on the latest research and trends in the medical fields. So should we as programmers.

Our job is to be the best programmers we can be. Fatigue should be irrelevant. Even if you are working in a world were the language features and APIs aren’t moving forward there is still a lot you can do. Read up on patterns and anti-patterns, if you haven’t read Code Complete, do so. I find the idea that programmers are perfectly happy to rest on their laurels completely ridiculous. Strive to become a better programmer, push yourself and your knowledge. As you become better at your job you will become a better person all-around. Knowledge is power.

If you stay current fatigue isn’t an issue. By keeping current incrementally there won’t be any fatigue. Start reading up on .Net 4.0 right now. By the time .Net 4.0 releases you will be pretty caught up and boom!, no more fatigue.

You may say, “Well, my job is to use this or that API or SDK. Knowing anything outside of that is irrelevant.” To that I’m calling “Bullshit!” It’s not about just writing code. If being a programmer was just about writing code then anybody could be a programmer. Writing code is easy. Writing code cleanly, efficiently so it’s easy to maintain, now that takes some skill. The best way to do so is to stay current.

Saying that you’re experiencing “fatigue due to the pace of Microsoft Technology introductions” is a serious cop-out. Staying current is your job because the more current you are the better programmer you are. If I was a fry-cook I’d want to be the best damn fry-cook on the planet, learn the lingo, find the right temperature for the grill so it cooks the eggs and burgers efficiently, work on recipes that taste good and can cook fast. I’m not a fry-cook, however, I’m a computer programmer. Being the best programmer I can be means that I have to stay current on new technology. Screw fatigue.

Thank you, that’s my time

high-pitched whine as I drop the microphone