Stupid .NET 1.1 Service Pack 1

Service pack 1 strikes again. This is part of a general use utility that I frequently use. An odd bug that came out of this is that the overloaded method was added in Service Pack 1 for .net v1.1 BUT NEVER DOCUMENTED!!!. Well, ok that’s not entirely true It is documented… in v2.0 documentation. So […]
A Standard CRC-16 and CRC-16 Kermit implementation in C#

Been a while since I posted anything, but here’s an update to my original CRC-16 class that does CRC-16 with CRC-CCITT Kermit code that I posted over on Stack Overflow a while ago. Unlike the code over there this doesn’t have a static look-up table (feel free to get the code from over there if […]
A CRC8 implementation in C#

So I’ve tackled CRC32, CRC16, CRC16-CCITT (and now CRC16-CCITT Kermit) implementations, and found myself wanting a CRC8 class to create checksums for small data (1-2 bytes) sets. Not having ever used or seen CRC8 in use before, I did some reading, and as far as I can tell, I’ve implemented it correctly… It works anyway, […]
Pre-increment vs post-increment operators

OK, so here’s a question for you that most people should have learned in school, but didn’t. You have to answer this without running to visual studio. Is it A) 1 2 3 4 or B) 0 1 2 3 4 I’m sure there are quite a few who would choose A, but this is […]
A C# Command Line Args processing class

The other day I was working on our video game’s content server app. The way its set up is fairly complicated. It basically has 3 modes that it can run in (as a windows service, as a fully blown console shell, or as a windows application). Being tired of writing long ugly blocks of code […]
C# .NET Single Instance Application

Today I wanted to refactor some code that prohibited my application from running multiple instances of itself. Previously I had use System.Diagnostics.Process to search for an instance of my myapp.exe in the process list. While this works, it brings on a lot of overhead, and I wanted something cleaner. Knowing that I could use a […]
Creating Fake Enums

In .NET Enums are a strongly typed flag-like object. Flags would normally defined as a macro, or constant variable. The trouble with typical numeric flags is that a) the coder using the flag may or may not know all of the possible values, or b) might accidentally type the wrong constant or macro. Since the […]
C# 3.0 Lambda expressions

I’ve finally seen the light for these little buggers. As I wrote in my original post that I really didn’t glean much from the description of lambda expressions that are mentioned in the specification, but I ran across a great article on it on the code project that did a really good job at explaining […]
.NET Reflection

What is reflection? Its the image we seen in a mirror. In .NET however its a system that lets you do at runtime what you would normally do in a text editor or visual studio. Like most object oriented programming languages, .net has the concept of a “type.” a Type defines what an object is. […]
Standard CRC 16 in C#

I’ve been working on a service at work that will end up being this big cluster of servers that all talk with each other. One of the things I needed was a small CRC checksum for some of the more compact UDP messages that get sent around. I thought about just using the CRC16-CCITT library […]

C# Articles

Stupid .NET 1.1 Service Pack 1

Service pack 1 strikes again.

    using System;
    using System.Drawing;
    using System.IO;
    using System.Reflection;
    public class Resources {
        private Resources() {}
        public static Image LoadImageFromResource(string path) {
            Image i = null;
            using ( Stream s = 
                      Assembly.GetExecutingAssembly().GetManifestResourceStream(path) ) {
                if(s != null) i = Image.FromStream(s, true, true);
            }
            return i;
        }
    }

    using System;
    using System.Drawing;
    using System.IO;
    using System.Reflection;
    public class Resources {
        private Resources() {}
        public static Image LoadImageFromResource(string path) {
            Image i = null;
            using ( Stream s = 
                      Assembly.GetExecutingAssembly().GetManifestResourceStream(path) ) {
                if(s != null) i = Image.FromStream(s, true, true);
            }
            return i;
        }
    }

C#

This is part of a general use utility that I frequently use. An odd bug that came out of this is that the overloaded method

Image.FromStream(Stream, Boolean, Boolean);

Image.FromStream(Stream, Boolean, Boolean);

C#

was added in Service Pack 1 for .net v1.1 BUT NEVER DOCUMENTED!!!. Well, ok that’s not entirely true It is documented… in v2.0 documentation. So if you wrote this in 1.1 sp1 and deployed it to a machine without sp1 you’ll get a method not found exception when trying to load the image from stream using the above overload–non sp1 only has FromStream(Stream, Boolean)

Nothing like being incompatible with the same version of the framework eh?