Coronado Arms Lower Build

I finally got my lower parts kit for my Coronado Arms lower build out. I used a lower parts kit from PSA. The parts kit was a basic kit with a Magpul MOE stock and grip in Flat Dark Earth.

Everything went together well and looks great! Check out the video below for all of the details!

Coronado Arms Lower Receiver

I’ve been wanting to do an AR-15 build, from the ground up, for quite some time now. With the rush going on, it’s been hard to find parts, etc. But I was recently able to get my hands on a stripped lower receiver.

I picked up a Coronado Arms billet lower receiver (Model CA-15). This is my first billet receiver, my M&P15T has a forged lower, and every other AR-15 I’ve ever shot/handled has been forged. The CA-15 is made from 7075-T6 aluminium, with a black hard anodized finish. I’m excited to see how everything goes together and eventually shoots.

The overall look and feel of the lower is great. It’s light, but feels very sturdy and has extremely clean lines. Everything seems to be machined perfectly. There is no “extra” material and everything just looks precision about it.

I can’t wait to get my parts kit so I can build this thing out!



For the parts kit, I ordered a Palmetto State Armory (PSA) setup. It is a complete lower kit including a buffer tube and stock. It has a basic Magpul MOE stock, I haven’t had a lot of experience with Magpul stuff, so I’m looking forward to checking that out too. I went with PSA because it has decent reviews, it was a good price, and it was also instock. Finding parts here in California has been difficult at best.

As soon as the parts start rolling in I’ll do follow up posts on everything.

.NET 4.5 Task Based Console Application with Progress

Lets say you need to create a simple .NET 4.5 application for processing some data… The quickest way to do that is to create a new Console Application in Microsoft Visual Studio 2012. I’m assuming that you already know how to do all of that… If not, you can Google it!

Once you have that, the first thing we will do is start out with your work process, this will be the actual Task that does all of the processing. We’re going to use the Task in the most basic fashion, so if you need to do more with it, take a look at System.Threading.Task on MSDN.

Here is the initial code to get you started; a basic entry point that calls a task and then waits for it to complete.

static Task DoWorkAsync()
{
	return Task.Factory.StartNew(() => {
			//Do Some Work...
			Thread.Sleep(250);
		}
	});
}
static void Main(string[] args)
{
	// Start the Task
	Task t = DoWorkAsync();

	// Wait for the task to complete
	t.Wait();
}

With that code, you will get a simple application that will spin off a new thread that will run the code in the DoWorkAsync function. We call t.Wait() in the main thread so that the application doesn’t terminate before the task completes.

That is all it basically takes to write a simple Task based console application in .NET 4.5. But just for the sake of fun, lets add some more detailed processing and some way of reporting back some level of progress.

public static int spinnerPos = 0;
public delegate void UpdateProgressDelegate(float pctComplete);
public static UpdateProgressDelegate UpdateProgress = (float pctComplete) => {
	if (pctComplete >= 100f) {
		Console.Write("\rProcess Complete!".PadRight(Console.BufferWidth));
	}
	else {
		char[] spinner = new char[] { '-', '\\', '|', '/' };
		Console.Write(string.Format("\rWorking... {0} - {1:0.0}%", spinner[spinnerPos], pctComplete).PadRight(Console.BufferWidth));
		spinnerPos = (spinnerPos >= 3) ? 0 : spinnerPos + 1;
	}
};

static Task DoWorkAsync()
{
	return Task.Factory.StartNew(() => {

		// Show the starting progress
		UpdateProgress(0f);

		int loopCount = 15;
		for (int i = 0; i < loopCount; i++) {

			Thread.Sleep(250);

			// Update the progress
			float pctComplete = (((float)(i + 1) / (float)loopCount) * 100f);
			UpdateProgress(pctComplete);
		}
	});
}

static void Main(string[] args)
{
	// Start the Task
	Task t = DoWorkAsync();

	// Wait for the task to complete
	t.Wait();

	Console.Write("\r\n\r\nDone!");
	Console.ReadLine();
}

With these updates the application will report back some basic progress to the console using a simple delegate.

Take the code and play around with it; it’s a good base for any long running process in a console application.

IP Adress Change Notifications

I’ve always had some sort of server at my house, for various reasons, but one thing that I never have to go along with those servers is a static IP address. Either they are way too expensive and not worth it for something that I am not making any money from, or they are completely unavailable. One day, hopefully my ISP will provide them for something other than a huge monthly business package, but that is probably wishful thinking.

Because I have servers, and this dynamic IP address, every once in a while my IP address changes. It’s much less frequent than I thought it would be, but it still happens from time to time. And since it doesn’t happen often, it’s usually one of those things I don’t notice until I am away from home and trying to access something on one of my servers, with no way to check the new IP address. I also try to keep some DNS records updated with the address, for easy reference.

So, my solution was to make a simple WebAPI service that simply returns the clients IP address, and then to have a simple application that consumes that service and keeps track of the addresses that are returned. Once a change is found, it will shoot out an e-mail to me with the new address and a reference to the old address. Then I can update my DNS, etc… No more unknown address changes. And if it changes while I’m out of the house, I will still be able to get access to my systems.

The WebAPI is very simple, just a Get() method with some very simple IP logic in it.

public class IpPingController : ApiController
{
	public string Get()
	{
		string ipAddr = HttpContext.Current.Request.UserHostAddress;
		if(string.IsNullOrEmpty(ipAddr)) {
			object property;
			Request.Properties.TryGetValue(typeof(RemoteEndpointMessageProperty).FullName, out property);
			RemoteEndpointMessageProperty remoteProperty = property as RemoteEndpointMessageProperty;
			if (remoteProperty != null) {
				ipAddr = remoteProperty.Address;
			}
		}
		return ipAddr;
	}
}

You can test this service by hitting this address in your browser, http://www.santsys.com/api/ipping/.

The application is a very simple console application that I run using windows scheduled tasks. I have it setup to run every 2 hours.

private static Configuration _cfg = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
public static Configuration Config { get { return _cfg; } }
public static string ApiAddress { get { return ConfigurationManager.AppSettings["IpPingAddress"]; } }
public static string PreviousIpAddress
{
	get { return ConfigurationManager.AppSettings["PreviousIpAddress"]; }
	set { _cfg.AppSettings.Settings["PreviousIpAddress"].Value = value; }
}
public static string LastUpdate
{
	get { return ConfigurationManager.AppSettings["LastCheck"]; }
	set { _cfg.AppSettings.Settings["LastCheck"].Value = value; }
}
public static string SmtpHost { get { return ConfigurationManager.AppSettings["SmtpHost"]; } }
public static int SmtpPort
{
	get
	{
		string port = ConfigurationManager.AppSettings["SmtpPort"];
		int iPort;
		if (int.TryParse(port, out iPort)) {
			return iPort;
		}
		return 25;
	}
}
public static string SmtpUser { get { return ConfigurationManager.AppSettings["SmtpUser"]; } }
public static string SmtpPassword { get { return ConfigurationManager.AppSettings["SmtpPassword"]; } }
public static string SmtpFrom { get { return ConfigurationManager.AppSettings["SmtpFrom"]; } }
public static string SmtpTo { get { return ConfigurationManager.AppSettings["SmtpTo"]; } }

static void Main(string[] args)
{
	try {
		DoWork();

#if DEBUG
		Console.Write("\r\nPress any key to exit.");
		Console.ReadKey();
#endif
	}
	catch (Exception ex) {
		Console.WriteLine("{0}\r\n\r\n{1}", ex.Message, ex.StackTrace);
	}
}

public static void DoWork()
{
	Version ver = Assembly.GetAssembly(typeof(Program)).GetName().Version;
	Console.WriteLine("IpPing v{0}.{1} build {2}", ver.Major, ver.Minor, ver.Revision);
	Console.WriteLine("\r\nLast Run: {0} @ {1}", PreviousIpAddress, LastUpdate);
	Console.Write("\r\n");

	if (string.IsNullOrEmpty(ApiAddress)) {
		Console.WriteLine("Error: No Api Address found in configuration. (IpPingAddress)");
		return;
	}

	HttpClient client = new HttpClient();
	client.BaseAddress = new Uri(ApiAddress);

	// Add an Accept header for JSON format.
	client.DefaultRequestHeaders.Accept.Add(
			new MediaTypeWithQualityHeaderValue("application/json"));

	HttpResponseMessage response = client.GetAsync("api/IpPing/").Result;
	if (response.IsSuccessStatusCode) {
		var ipAddrInfo = response.Content.ReadAsAsync<string>().Result;

		Task emailUpdate = null;

		// if the IP Address has not changed
		if (PreviousIpAddress != ipAddrInfo) {
			Console.WriteLine("New IP address detected.\r\n\tOld Address:{0}\r\n\tNew Address:{1}\r\n\r\nSending notification.", PreviousIpAddress, ipAddrInfo);
			emailUpdate = SendUpdateEmail(ipAddrInfo, PreviousIpAddress);
			PreviousIpAddress = ipAddrInfo;
		}

		LastUpdate = DateTime.Now.ToString();
		Config.Save(ConfigurationSaveMode.Modified);
		ConfigurationManager.RefreshSection("appSettings");
		
		// wait for the email to send, if one is being sent
		if (emailUpdate != null) {
			emailUpdate.Wait();
		}
	}
	else {
		Console.WriteLine("Error: {0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
	}
}

public static Task SendUpdateEmail(string newIp, string oldIp)
{
	return Task.Factory.StartNew(() => {
		try {
			SmtpClient smtpClient = new SmtpClient(SmtpHost, SmtpPort);
			if (!string.IsNullOrEmpty(SmtpUser) && !string.IsNullOrEmpty(SmtpPassword)) {
				smtpClient.UseDefaultCredentials = false;
				smtpClient.Credentials = new NetworkCredential(SmtpUser, SmtpPassword);
			}
			MailMessage msg = new MailMessage(SmtpFrom, SmtpTo);
			msg.IsBodyHtml = true;
			msg.Priority = MailPriority.High;
			msg.Headers.Add("X-IP-PING", "Automated message from IP PING");
			msg.Headers.Add("X-IP-PING-ADDRESS", newIp);
			msg.Subject = "Ip Address Changed!";
			msg.Body =
					"<style type=\"text/css\">body, p { color: #555; font-size: 12px; font-family: Arial; } a, a:link, a:visited { color: #486db5; text-decoration:none;}</style>"
				+ "<p style=\"color: #555;font-size: 12px; font-family: Arial;\">This is a notification from Ip Ping. Your IP Address has changed.</p>"
				+ "<p style=\"color: #555;font-size: 12px; font-family: Arial;\">Your new IP Address is <b style=\"font-size: 14px; color: #000;\">" + newIp + "</b></p>"
				+ "<p style=\"color: #555;font-size: 12px; font-family: Arial;\">Your old IP Address was " + (string.IsNullOrEmpty(oldIp) ? "(blank)" : oldIp) + "</p>"
				+ "<br /><br /><p style=\"color: #666;font-size: 10px; font-family: Arial;\">© " + DateTime.Now.Year.ToString() + " Santomieri Systems - <a href=\"http://www.santsys.com/\">www.santsys.com</a></p>";

			smtpClient.Send(msg);
		}
		catch (Exception ex) {
			Console.WriteLine("{0}\r\n\r\n{1}", ex.Message, ex.StackTrace);
		}
	});
}

That’s pretty much it. Feel free to use this if it will help you out. I know it solved a lot of issues for me.

Theis Holsters IWB

I recently purchased a Theis Holsters Inside the Waistband (IWB) holster… It’s a form of cross bread holster, part Kydex and part leather. In my limited experiences, I’m finding that this form of holster is much more comfortable because it molds to your body better. I’ve found with pure Kydex style holsters, they are more one-size fits all, so they usually cause some uncomfortable pinching or just feel strange, especially after many hours of wear.

For IWB carry, I like something that is easy for holstering, drawing and then re-holstering a firearm. It’s much smoother for training, and I find more convenient for the simple things like just putting your pants and belt on. I also prefer something that maintains its shape a bit better. So all of that is boiling down to the fact that I like something that is part Kydex. So the best of both worlds, in my mind, is the cross-bread type holsters.

Breaking it down, Theis Holsters offers holsters in multiple fashions (IWB and OWB) and for a very large collection of firearms. I’m just going to cover the IWB holster, because that is what I have.

The options for the IWB holsters, once you choose your firearm type, are the type of leather you want (horsehide or cowhide), the type of clips you want (metal, Kydex, or J-Clips), and finally if you want standard or full muzzle coverage.

For my holster, I chose horsehide, metal clips and the standard muzzle coverage.

I decided to go with the horsehide per the recommendations on the site. Theis notes the following positives about the horsehide…

  • They are stronger, yet thinner than cowhide, making them easier to conceal.
  • Horsehide does not absorb sweat like cowhide, because it is more dense and much more durable than cowhide.
  • The horsehide I use is 100% natural with no color or dyes to stain your clothing.

With my couple of weeks of usage, I would have to agree 100%. The thickness is about the same as one of my cowhide holsters and just has a better overall feel about it. Also, I’ve noticed that it hasn’t been absorbing a lot sweat, it has changed a little in color, getting a bit darker. So I would assume its absorbing a bit. But its not noticeable. I also often wear a white undershirt, so the holster is not rubbing directly on my skin, I just don’t like the feeling of any holster on my bare skin. But I haven’t noticed any discoloration on any of my shirts, even after wearing it for 10-12 hours non-stop.

I did decide to use some leather conditioner on the holster. Its something that I use on most leather items that I get. Its called saddle soap, and it’s amazing. You can get some here, Kiwi Saddle Soap The results turned out great… I didn’t go crazy with it, just gave it a little coating to help protect it. In a couple months I’ll give it another coating to clean/protect it. Just something I think will help the holster last longer.

Next up is the clips, I chose the metal clips because I’ve had good luck with them in the past, so I figured why change it. If it ain’t broke don’t fix it!

And finally, I also chose to get the normal muzzle coverage, not the full coverage, for more versatility between firearms. e.g. a Glock 17 and a Glock 23. If you get the full muzzle coverage for a Glock 23, the Glock 17 wont fit. So I figured having an open muzzle was the best choice. And so far, I am very happy with that choice. I’m not concerned about my pants getting a little dirty or anything like that.

For my preferences, I did make a couple modifications to the holster. The leather that protects your side from the slide of the gun stuck out a bit to far for my tastes… Basically it was interfering with my grip when trying to draw my weapon. Your results may vary, but I simply used a razor knife to cut away about a 1/4 inch of material. Here is what it looks like with that done.

After that, drawing was clean and easy, and I didn’t have any obstructions. Depending on your gun, your body type, and the size of your hands you may need to cut more, less, or none at all. But remember, you need to practice. A change in holster is a major thing, especially when your life may depend on it. It can alter everything about your shooting. So make sure to do dry fire practice, and then go to the range and practice. Practice. Practice. Practice!

So, other than the little trimming that I needed to do, I’ve found this holster to be one of the best I’ve ever used and I love it. The retention is great, out of the box, though Theis does give you instructions on how to remold some of the Kydex if you want to change the retention. He also sends out very detailed instruction on the holster and what to expect with it. Like anything new and good, it takes a little time to break in. Though most of the things he mentions that “might happen” never happened or I never noticed. For example, holster squeak.

Bottom line, check them out and give them a try. You will not be disappointed.

http://www.theisholsters.com

Meprolight Tru-Dot Night Sights

I finally decided to pull the trigger, so to speak, and get
some upgraded sights on one of my Glocks. It’s been something that I had been
thinking about doing, but was on the fence for a while… I was hung up on what
brand to get, where to get them installed, and then how would I adjust them if I
needed to (not that I could adjust the factory sights either).

I took a look at the Trijicon and Meprolight sights at one
of my local gun shops, City Arms East in Pleasant Hill, CA.
It was strangely one of the only places I could find that would sell them to
me, and actually install them. Northern California, amongst its many issues,
really is lacking places for gun accessories and gunsmiths. I like to at least
attempt to support local, or semi-local, brick and mortar businesses, but that
is becoming harder and harder these days. They have to charge so much, that in
most cases, I just can’t justify spending the extra money. But, I digress…

The reason I chose the Meprolight sights, really was just a
factor of availability. The gun shop had the correct ones for my gun, and would
install them while I waited (it took about 10-15 minutes). The difference
between the two brands are pretty small from what I could tell. This is not
really going to be an in-depth discussion on, or a comparison of the different
brands, but simply a discussion of what I like about the Meprolights and what
my impressions are of them now that I’ve used them briefly.

So first things first, the basic construction of them is good. They are sturdy and have clean
lines. They don’t appear to have any burrs or discrepancies with the actual
sight dots and the dots glow quite bright in the dark, even after being tucked
away and out of the light for quite a while.

I did some initial low light shooting, and the dots were
surprisingly bright, and very easy to get a good sight picture with. I know,
from trying this with the factory sights, I would lose the sights in the
background when it got dark. With these, that’s not going to be a problem, not
in the least.

The model that I have are the ML-10222 (for 10mm and .45
ACP) with orange rear dots and a green front dot. For more information on them
from Meprolight, take a look here. You can also
take a look at them on Amazon, here (the ones on Amazon are a different model, so make sure to get the right ones
for your firearm).

A thing to note, and I’m sure this will pass with more
practice and usage, but I’ve noticed that I occasionally have a hard time
focusing on the front sight when the sights are glowing brightly (in very low
light situations). I think this is mostly related to the sensitivity of my
eyes, and it’s a different experience seeing these illuminated dots when its
dark. I can’t really explain the specifics, but it’s something that I thought
was worth mentioning. With a couple of dry-fire practice sessions, it’s getting
less and less pronounced. So I think with more training and getting used to
them, it will be a complete non-issue. This goes to show you that NOTHING makes
up for constant and consistent training with your firearms, especially if your
life depends on it.

RFC 4648 Base32 Encoding

I have been playing around with writing some basic encoders, figuring a good first step would to start with something on the easier side, I decided to jump in with a Base32 encoder.

First things first, here are some details on Base32 from RFC 4648, Section 6.

 

The Base32 encoding is designed to represent arbitrary sequences of octets in a form that needs to be case insensitive but that need not be human readable.

A 33-character subset of US-ASCII is used, enabling 5 bits to be represented per printable character. (The extra 33rd character, “=”, is used to signify a special processing function.) The encoding process represents 40-bit groups of input bits as output strings of 8 encoded characters. Proceeding from left to right, a 40-bit input group is formed by concatenating 5 8bit input groups. These 40 bits are then treated as 8 concatenated 5-bit groups, each of which is translated into a single character in the base 32 alphabet. When a bit stream is encoded via the base 32 encoding, the bit stream must be presumed to be ordered with the most-significant- bit first. That is, the first bit in the stream will be the high-order bit in the first 8-bit byte, the eighth bit will be the low- order bit in the first 8bit byte, and so on. Through the development process, I came up with 3 basic designs for the process.

Each 5-bit group is used as an index into an array of 32 printable characters. The character referenced by the index is placed in the output string. These characters, identified in Table 3, below, are selected from US-ASCII digits and uppercase letters.

In my tinkering around with this, I came up with a couple of options, some quick and dirty, and some a
little more in-depth. I’ll outline each of the methods that I used, and surprisingly they all seemed to perform within about a 1/1000th of a second (in some very basic performance testing that I did).

The first method that I tired was basically a simple method that took 1 bit at a time and shifted it into a buffer. This method, simply put, builds the 5-bit blocks bit-by-bit.

public static string ToBase32String(byte[] bytes) {
	 if (bytes == null || bytes.Length < 1) return string.Empty;
	
	 StringBuilder sb = new StringBuilder();
	 byte index = 0;
	 int hi = 0;
	 int currentByte = 0;
	 int totalBytes = bytes.Length;
	
	 byte workingByte = bytes[currentByte];
	 int bits = 0;
	 index = 0;
	 
	 while (true) {
		index = (byte)((index << 1) | ((workingByte >> (7 - bits)) & 1));
		bits++;
		hi++;
		
		if (hi == 5) {
			if (index == 0 && currentByte >= totalBytes) { index = 32; }
			sb.Append(ValidRFC4648Chars[index]);
			if (index == 32 && ((sb.Length > 8 && (sb.Length % 8) == 0) || (sb.Length == 8))) { break; }
			index = 0;
			hi = 0;
		}
	
		if (bits == 8) {
			currentByte++;
			bits = 0;
			if (currentByte >= totalBytes) {
				workingByte = 0;
				if ((sb.Length % 8) == 0 && sb.Length >= 8) { break; }
			}
			else {
				workingByte = bytes[currentByte];
			}
		}
	}
	
	 if (sb.Length < 8) { return sb.ToString().PadRight(8, '='); }

	 return sb.ToString(); 
}

 

The next method that I tired, was the simplest method. I say simplest because it uses the most built in .Net stuff and doesn’t do as much binary arithmetic and bit shifting. I created a bit string (base-2 number string) using Convert.ToString(byte, 2) then I pull 5-bit (in this case, 5-character) chunks from the string and then encode them.

public static string ToRFC4648Base32_Strings(byte[] bytes) {
	 StringBuilder sb = new StringBuilder();
	 int pos = 0;
	 byte index = 0;
	 StringBuilder byteString = new StringBuilder();
	
	 foreach (byte b in bytes) {
		byteString.Append(Convert.ToString(b, 2).PadLeft(8, '0'));
	 }
	
	 string bString = byteString.ToString();
	
	 while (pos < (byteString.Length / 5)) {
		index = Convert.ToByte(bString.Substring(pos * 5, 5), 2);
		pos++;
		sb.Append(ValidRFC4648Chars[index]);
	 }
	
	 if ((pos * 5) < byteString.Length) {
		index = Convert.ToByte(bString.Substring(pos * 5).PadRight(5, '0'), 2);
		sb.Append(ValidRFC4648Chars[index]);
	 }
	
	 while ((sb.Length < 8) || (sb.Length > 8 && sb.Length % 8 != 0)) {
		sb.Append("=");
	 }

	 return sb.ToString(); 
} 

The final method, the one that I like the best, pulls the data out in a more block based manner and really just accomplishes the task.

public static string ToRFC4648Base32(byte[] bytes) {
	if (bytes == null || bytes.Length < 1) return string.Empty;

	StringBuilder sb = new StringBuilder();
	int currentByte = 0;
	int start = 0;
	int stop = 5;
	byte workByte = 0;
	byte index = 0;

	int numBytes = bytes.Length;

	while (currentByte < numBytes || (sb.Length < 8 || (sb.Length > 8 && sb.Length % 8 != 0))) {
		if (start == 0) {
		workByte = (byte)(bytes[currentByte] >> 3);
		start += 5;
		stop += 5;
	}
	else {
		if (currentByte < numBytes) {
			workByte = bytes[currentByte];
		}
		else {
			workByte = 0;
		}

		workByte = (byte)(((workByte << start) & 0xff) >> 3);
		byte nextByte = 0;
		if (stop > 8) {
			if (currentByte < numBytes - 1) {
				nextByte = bytes[++currentByte];
			}
			else {
				currentByte++;
			}
			workByte = (byte)(workByte | (nextByte >> (16 - stop)));
			start -= 3;
			stop -= 3;
		}
		else {
			if (currentByte < numBytes) {
				nextByte = bytes[currentByte];
			}
			else {
				nextByte = 0;
			}
			workByte = (byte)(workByte | ((nextByte & (((1 << (8 - stop)) - 1) << (8 - stop)))));
			start += 5;
			stop += 5;
		}
	}

	if (workByte == 0 && currentByte == numBytes && (numBytes % 5) == 0) break;
	index = workByte;

	if (index == 0 && currentByte >= numBytes) index = 32;
		sb.Append(ValidRFC4648Chars[index]);
	}

	return sb.ToString(); 
}

From the limited testing I did, the latter code performed an average encoding speed of 103,057,258-bit/s. For the testing I encoded 5000 blocks of 32-bytes of random data. On average it took 0.0124028 seconds to perform those encodings. Your results, and math may vary.

With all of these, I’m sure there are many things that could be done to improve performance, but for my playing around they perform perfectly well. Feel free to use and update as you wish!

Exchange Online Connected Accounts

When I initially switched over to Exchange Online a couple of weeks ago, I was stoked for the “Connected Accounts” functionality that it offered. The idea of a consolidated inbox sounded too good to be true. Unfortunately that proved to be all too true. This isn’t a total bash on the feature, it’s just not something that really “works” for what I was trying to do with it (and hoped it would be able to do).

So first things first, here is what it does ok… It downloads e-mail from (up to 5) POP/IMAP accounts and puts that mail into your Exchange Inbox. It allows you to send messages “on behalf of” those connected accounts on systems that can handle it. In my trials, for actually sending mail from the connected accounts, Outlook and the Outlook Web Client that is provided were the only systems able to correctly use the connected accounts to send. iOS devices send from the default Exchange account when replying to a message, not the alternate address, and on top of that, you can’t even select the additional addresses as options to send from when creating a new message. So it pretty much doesn’t work at all in the case of iOS.

What it doesn’t do well (at all)… Is provide a transparent layer for multiple e-mail accounts. What I mean by that is that if you have two e-mail addresses, your main Exchange account, lets say user@domain.com and a connected account user@domain2.com; If you send an e-mail in Outlook from user@domain2.com, it will display to the receiver (depending on their mail client) basically saying the message was sent “on behalf of” user@domain.com. Here are some examples of how that looks in a few mail systems.

Outlook:


Gmail:


For someone like myself who is a consultant and has many e-mail addresses and doesn’t necessarily want clients to see e-mails coming from one address when they should be from another, it can be problematic. It can also make for unhappy employers, etc.

Gmail offers some ways around these issues, using “Send mail as” functionality that has a much cleaner implementation and actually allows you to use external SMTP servers to send mail. So no more “on behalf of” in your connected accounts messages. It also allows you to join up POP/IMAP accounts to download messages.

This leads to the logical progression of why didn’t I just use Gmail (and Google Apps) instead of Exchange Online? Well, for me, I like the other features of Exchange, like the Calendar, Contact syncing and just the overall experience of the Exchange System. Also, the overall integration with Outlook is quite nice. The Gmail experience might be up to par now, but in my past experiences, the actual Exchange integration just works better.

So, you might ask next, what did I decide to do? Well, it’s not really a work around, or even some other form of consolidation. What I ended up doing is adding all of my accounts individually to Outlook, on my iPhone and my iPad. And you guessed right, that means a lot of accounts. But, it does offer some benefits… the main one being total segregation of my e-mail accounts, no messages will ever be sent on behalf of another account, etc. In Outlook, utilizing the Favorites section for mail, it allows me to see all of my main inboxes in one place and doesn’t really take away much from the experience. I am one of those Outlook users that is used to using the “Folder List” view, but I’m quickly adapting to mostly using the “Mail” view.

Here is what my favorites list looks, you can see the 3 main inboxes for the accounts I use most frequently at the top.

The main up-in-the-air items that are yet to be determined is the performance hit that Outlook will take, it’s now checking multiple accounts instead of just one Exchange account. And what the impact will be on the battery life of my phone and other mobile devices. My guess is that both Outlook and the mobile devices will take a hit, but hopefully it won’t be too bad.

Hopefully, Microsoft will update the Connected Account functionality sometime sooner rather than later, I know it would make me very happy. But until then, this should get the job done!

What are your thoughts?

Some more information: