Category: C#

I’m presently writing a framework that wraps a C API using interop. Many of the classes/structs defined in the C library already exist in .NET, but I have to re-implement them anyway so that I can interface with the library. People accustomed to the .NET classes won’t be fond of this because they already have a set of classes that work well, and the new ones won’t work with existing .NET methods. There is a simple solution to this, however! Implicit casting!

Here’s a sample of how I made my Color struct compatible with the one defined in System.Drawing.Color:

Note that System.Drawing.Color uses ints instead of bytes for its colors, and they aren’t necessarily stored in the same memory location, so I couldn’t use that class directly. You can, however, convert back and forth between the two classes without any loss of data, so this is a perfect case for implicit casting. If the two classes aren’t convertible without some data changing, you should use explicit casting instead, or perhaps a static factory method.

I was curious, however, to know what would happen if an implicit casting method was defined in both classes. Here’s an example:

How does it know which method to call? The answer: it doesn’t! This actually gives the following error:

Ambiguous user defined conversions ‘ImplicitTest.A.implicit operator ImplicitTest.B(ImplicitTest.A)’ and ‘ImplicitTest.B.implicit operator ImplicitTest.B(ImplicitTest.A)’ when converting from ‘ImplicitTest.A’ to ‘ImplicitTest.B’

There is a way you can still utilize one of conversion methods, but it isn’t pretty. Here’s the solution work-around:

[credit]

The real solution would be to just delete one of the methods, if you can!

You can use this class to resize images proportionally (maintaining aspect ratio), or to resize an image to an exact size and crop off excess (useful for making nice thumbnails):

public static class ImageExt {

  public static Image Resize(this Image img, int srcX, int srcY, int srcWidth, int srcHeight, int dstWidth, int dstHeight) {

    var bmp = new Bitmap(dstWidth, dstHeight);

    using(var graphics = Graphics.FromImage(bmp)) {

      graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

      graphics.CompositingMode = CompositingMode.SourceCopy;

      graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

      using(var wrapMode = new ImageAttributes()) {

        wrapMode.SetWrapMode(WrapMode.TileFlipXY);

        var destRect = new Rectangle(0, 0, dstWidth, dstHeight);

        graphics.DrawImage(img, destRect, srcX, srcY, srcWidth, srcHeight, GraphicsUnit.Pixel, wrapMode);

      }

    }

    return bmp;

  }



  public static Image ResizeProportional(this Image img, int width, int height, bool enlarge = false) {

    double ratio = Math.Max(img.Width / (double) width, img.Height / (double) height);

    if (ratio < 1 && !enlarge) return img;

    return img.Resize(0, 0, img.Width, img.Height, M2.Round(img.Width / ratio), M2.Round(img.Height / ratio));

  }

  public static Image ResizeCropExcess(this Image img, int dstWidth, int dstHeight) {

    double srcRatio = img.Width / (double) img.Height;

    double dstRatio = dstWidth / (double) dstHeight;

    int srcX,

    srcY,

    cropWidth,

    cropHeight;

    if (srcRatio < dstRatio) // trim top and bottom 

    {

      cropHeight = dstHeight * img.Width / dstWidth;

      srcY = (img.Height - cropHeight) / 2;

      cropWidth = img.Width;

      srcX = 0;

    } else // trim left and right 

    {

      cropWidth = dstWidth * img.Height / dstHeight;

      srcX = (img.Width - cropWidth) / 2;

      cropHeight = img.Height;

      srcY = 0;

    }

    return Resize(img, srcX, srcY, cropWidth, cropHeight, dstWidth, dstHeight);

  }

}

You can use this little function to convert a decimal to any base. I use it for compacting large numbers.

Or you can use it to make a nice GUID:

This is a simple class I wrote to nicely format a JSON string. Just call it with JsonFormatter.PrettyPrint(yourJsonString)

A couple times now I’ve wanted to subtract one set (`HashSet`) from another. `HashSet` has a method ExceptWith that does just this, except that it modifies the current set in place. What if you don’t want that? You need to copy it first.

Or you could use Linq’s Except method, except that it returns `IEnumerable` instead of a `HashSet`. What if you don’t want that? You need to convert it.

So… which method is faster? Let’s find out!

On my computer, this outputs:

Linq: 1291 ms
Native: 756 ms

So, clearly the second method is faster. About 40% for you math types.

I should note that “clone” isn’t really a clone, it’s a shallow copy. Only the container class itself is “cloned”; the elements still refer their originals.

Here’s an extension method to slice strings in C#, similar to Python’s slice notation.

The easiest way to deep copy an object is to serialize and deserialize it. Here’s an example from a project I’m working on:

You might need to implement the serialization functions too for this to work, however.

I’m probably posting this too early; I haven’t had a chance to extensively test it yet but I basically just locked every function down, and made any method that actually modifies the list run on the main thread so that notifications can be sent. It ought to work 🙂

You can simply delete the “where T : INotifyPropertyChanged” if you don’t like that restriction, but I put it there so that you don’t forget that your objects should notify your controls that their properties have changed, so that the GUI gets refreshed properly.