First some background:
You wrote:
"In an 24bpp type, these values are scanned then converted to byte then assigned to the bitmap image."
Every scanner I have seen in a previous job, which included scanners by Canon, HP, Konica Minolta, Toshiba, and more, all scanned color images that were subsequently converted to grayscale images with a grayscale palette.
The conversion is:
GrayColor = 0.299 Red + 0.587 Green + 0.114 Blue.
(Note that 0.299 + 0.587 + 0.114) add up to 1.0).
For the BMP image format, the GrayColor value would be used an index into a color palette associated with the BMP image format, where each (RGB) color in the palette has the same R, G, and B value, and each of these values at a particular index is the same value as the index.
In other words, Grayscale is implemented as a color image with a color palette, just all the colors in the palette are grayscale colors. The colors, in order, and skipping most central colors, are (0, 0, 0), (1, 1, 1), (2, 2, 2,), ... (254, 254, 254), (255, 255, 255).
------------------------------------------------------------
In the case you pose, you can create a BMP image with a palette that has 65536 RGB entries that range from (0, 0, 0) to (65535, 65535, 65535). Then each color entry would be a 16-bit index into the palette. Microsoft supports this image format. I don't know if this is supported in C#, but it would be easy to check that.
.NET 4.5 (and earlier versions?) provides an easy way to make a 16-bit palette - see:
http://msdn.microsoft.com/en-us/library/system.drawing.graphics.gethalftonepalette%28v=vs.110%29.aspx
However, WPF will only display values in the range of 0 to 255 regardless of the source. So, you can store the image data in high-resolution, but I do not know how to view the image at full luminance resolution.
Like Bill Woodruff, I question the need for that amount of luminance precision in an image. Most advanced sensors in scanners typically produce 12-bits or less of color accuracy, so 16 bits is probably overkill. Most displays don't allows rendering such fine shade differences, and even if they did, I don't think adjacent colors in the palette would be discernably different to the human eye. However, your case might be unique - but if it isn't, I'd go with an 8-bit palettized image - that format takes up a lot less space.
To write the code you want, find the standard 8-bit grayscale case and convert the values to 16-bit. The palette will go from being 256 32-bit RGB values (one byte is unused) to a palette of 65536 32-bit RGB values. (Palette entries are always 32-bit in the BMP image format - the most significant byte can be set to 0 - or ignored. Then change the byte value to be short values and adjust all the loop indexing accordingly. I hope that helps.
Updated 1-Dec-13 14:32pm
v3
The 32-bit entries mentioned are for pallete entries for images that take a palette.
Because you are specifying Red, Green, and Blue separately for each pixel, you don't need a pallete.
I don't know if the BMP format, which is a file format (BITMAPINFO structure in C++) supports more than 32 bits-per-pixel. If C# has a PixelFormat.Format48bppRgb format, then it must support that image format - this is probably for images taken with modern cameras that have more than 8 bits per color component.
However, WPF, and the vast majority of graphics cards (all of them?) don't support more than 16,777,216 colors, that is 24-bit color with 8-bit color components.
-------------------------------------------
I have a question for you. You stated what you are trying to do, but you didn't state what wasn't working. Does anything display? Does the program crash? What happens?
Did you try what is at the link in Bill Woodruff's message?
Updated 3-Dec-13 14:59pm
v5