Archive for June, 2009
I’m on vacation this week. I’ll be back to posting on June 23, 2009.
I recently had an email conversation with a former colleague. He works at an organization that uses some pretty cutting edge technology. My feeling is that the organization firmly understands the value of moving to the latest and greatest is fraught with peril but rewards the early pioneers if these moves happen appropriately. In particular, they are already evaluating Oslo. I’m a big fan of proactive thinking. I have long heard rumors that the Chicago market is too backward or old fashioned, and I just don’t see that. Instead, I hear that a Chicago business is actively hiring and is using the latest and greatest technology to make their business more competitive.
We also have a very active Ruby and Python community which, from what I can tell, is growing every month. I think that the city has already turned itself into a tech hub. We just need that first billion dollar company and the world will know too. I know this will take 7-10 years for the seeds to start bearing fruit, but the process is in motion.
I love this!
This is day #3 of my journey through the .NET 4.0 assemblies. I’m planning to split up large assemblies over several days so that I give bigger assemblies proper treatment. Today, that won’t be happening! By the way, this is actually turning out to be pretty neat. .NET ships with a lot of interesting pieces, and the assemblies that sort early in the alphabet (because they don’t start with System) are pretty interesting glimpses into how .NET does things.
Today, we look at IEExecRemote. This assembly contains a single type:
IEExecRemote, Version=18.104.22.168, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
In GAC: True
Number of types: 1
Number of namespaces: 1
So, what does this IEExecuteRemote do? Reading the docs, we see that this is another class that “supports the .NET Framework infrastructure and is not intended to be used directly from your code.” So what? What does it do? It runs a managed application over the Internet. OK, that’s kind of generic and not very helpful. What is really going on? When you start a .NET application via a URL, Windows fires up an application called IEExec.exe. This KB article describes the process. This part of the discussion is pertinent:
The IEExec.exe application is an undocumented Microsoft .NET Framework application that is included with the .NET Framework. You can use the IEExec.exe application as a host to run other managed applications that you start by using a URL.
For example, when you start a smart client by using a URL, no processes run with the smart client name. Instead, each application that you start by using a URL receives its own copy of the IEExec.exe application. The IEEXEC.exe application sets up the appropriate environment for the application to run in.
Typically, the IEExec.exe application works closely with Microsoft Internet Explorer to help you start the .NET Framework applications. The IEExec.exe application hooks to Internet Explorer version 5.01 and later to listen for assemblies that are requested. During a request, the executable is downloaded to the assembly download cache. Internet Explorer spawns a process for the IEExec.exe application and then passes the raw evidence information of the executable to the IEExec.exe application. The IEExec.exe application then uses the raw evidence information to set up an environment that has constrained-security settings for the executable.
IEExecuteRemote and IEExec work together to host and run assemblies that are stored at URLs (instead of the local file system). IEExec loads the IEExecuteRemote instance in a separate AppDomain and then runs the remote assembly in that domain. The only method that IEExec excecutes on IEExecuteRemote is the ExecuteAsAssembly method.
Over the years, I’ve come to use Google for SOOOOOOO much. Over the past week, I changed my default search engine in Internet Explorer and Firefox over to Bing. From what I think I’m seeing, Bing slightly exceeds Google in effectiveness. It might be that the UI is a little fresher, the results have slightly better relevance, or just that it is something new. Regardless, after several days of really heavy use, I don’t think I’m returning to Google search anytime soon.
FWIW, I tend to type in sentence based queries as opposed to sophisticated boolean logic. Bing likes my questions better than Google does, and that let’s me get my job done faster.
From what I’m seeing, Bing is a little bit better. A little bit is enough for me to switch.
I’m on day 2 of going through assemblies in .NET 4.0. I may miss a day here and there, but I want to find out what is in all the libraries. For some of the bigger libraries, I think I’ll do a namespace breakdown over several days.
The assembly today is CustomMarshalers, and it has very few classes; 4 to be exact.
CustomMarshalers, Version=22.214.171.124, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
In GAC: True
Number of types: 4
Number of namespaces: 1
These classes all handle special scenarios for interacting with COM. Since there are only 4 classes, I’ll cover each.
The CLR will not use this marshaler automatically. You need to know when it is needed. When P/Invoking a function or declaring a CLR wrapper for a COM object, you may have an object that only implements IDispatchEx. IDispatch was originally created for Visual Basic and allows late bound dispatch to properties. In other words, it allows for duck typing. IDispatchEx allows for an object to add and remove methods to a given object and exists to support dynamic features of Windows Script Host (languages: VBScript and JScript).In the .NET world, one adds and removes members from a type by implementing the System.Runtime.InteropServices.IExpando interface. From reading the documentation, it appears that if your underlying COM object implements IDispatchEx, you should must the infrastructure to marshal to an IExpando.
MarshalTypeRef=typeof(ExpandoToDispatchExMarhsaler))] IExpando expando);
COM allows code to enumerate a collection of VARIANT data using the IEnumVARIANT interface. A VARIANT allows one to put an integer, boolean, string, or complex object inside of a uniform binary type. In .NET, one would have a bunch of COM values that one wants to treat as System.Object. The CLR knows to use this marshaler when marshalling between a COM IEnumVARIANT and a .NET IEnumerator.
COM contains an interface named ITypeInfo. ITypeInfo is used for reading information about objects. Type browsers use ITypeInfo to figure out the characteristics and methods of objects contained in COM type libraries. A type library will be in a .tlb file or embedded in the dll/exe. Compilers use ITypeInfo to compile references to members of a type. If you export a .NET type to COM, the tools that read ITypeInfo need a way to read the information about your .NET types as ITypeInfo. Fortunately, this public type is meant to be used by the framework and not by your code. Still, it’s good to know what the class does.
This type is automatically used when bridging between an System.Collections.IEnumerable and an IDispatch where a member with a DISPID of -4 (enumerable member) is present. You will typically interact with this class when using tlbimp.exe to consume a type library from within your .NET application.
Whew-that was a lot of detail to cover. I can’t promise to do this every day, but I know that COM interop is one of my weak points. As you find issues with these descriptions, let me know. These blog entries are simply documenting my trip through the class libraries and all the reading I’m doing.
One of the questions I had at the Chicago Code Camp in my Google App Engine presentation was about permissions on deleting values from table storage. In GAE, each item in the datastore has a globally unique key-absolutely unique across all entities in your application and, I believe, unique across all objects. The question was this: if I figure out an ID of your objects, can I cause a delete from a second GAE application?
Fortunately, no. At the time of this writing, I have an object (a picture) whose ID is ahJzc2VlbHktc2lsdmVybGlnaHRyDwsSCUltYWdlRmlsZRgCDA. I tried deleting that exact ID from a different application. The delete failed. So, the delete would only work if it comes from the application in question. That’s what I hoped happened, and it does.
Thanks for the great question!
In the spirit of DNRs “Better Know a Namespace”, I’m going to go ahead and try to understand what the 140 assemblies on my machine that appear to be part of .NET 4.0 actually do. I’ll go through these as I can, just as a way to know what exists. Here is the first one:
Accessibility, Version=126.96.36.199, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
In GAC: True
Number of types: 10
Number of namespaces: 1
Value type Accessibility._RemotableHandle
Value type Accessibility.__MIDL_IWinTypes_0009
This assembly provides the interfaces and struct definitions needed to interact with the Windows Accessibility system. The assembly is a managed wrapper for the COM accessibility interface. This interface helps assistive technology products work with applications. It also provides a way to access, identify, and manipulate an application’s user interface. Wikipedia has a great article on the technology.
For me, Hunter is the first deep contact I ever got into Microsoft. Way back when (1998!) I wrote a book called Windows Shell Programming. At that time, I was spending a lot of time in the Windows Shell newsgroups looking for answers as well as answering questions. At the time, Hunter was a Software Development Engineer in Test for the Windows Shell team. He quickly figured out that I was writing a book on his team’s product and did everything he could to help me understand how various features worked. Hunter is a big part of the reason that the book, my first, came out as well as it did. He actually made sure that I got decent answers from people on the shell team (Raymond Chen reviewed and answered a lot of my questions via Hunter). I didn’t realize that he is now a VIP in Azure land.
He’s a great person. I’m glad to see that he’s a big part of Azure. Way to go, Hunter!!!
I was digging through the .NET 4.0 assemblies and started with a group that is near and dear to my heart: System.ServiceModel.*. I know-that’s the super cool but really hard thing to understand in .NET, at least, that’s what I seem to see all the time. Last night, I poked around in System.ServiceModel.Channels-a new assembly in .NET 4.0. This assembly contains two interesting features:
- The ability to send messages in process.
- The ability to send blobs as is.
The in process channel was frequently asked for by users back in the Indigo beta days. As a matter of fact, this was typically the first channel that the channel team would write to make sure that the latest iteration of the channel model still worked and made sense. Then, the channel was checked into the build verification tests (BVTs), but never into the product. Finally, with .NET 4.0, that class has moved to production in System.ServiceModel.Channels.LocalTransportBindingElement and System.ServiceModel.LocalBinding.
The other interesting item is the blob encoder: System.ServiceModel.Channels.BlobMessageEncodingBindingElement.
I see that, right now, the web is quiet on the documentation for these classes. I’ll be testing them out ASAP and will share what I learn soon after.
Last night, Lake County Illinois had some fierce lightning going on. When the cloud is ready to make a lightning flash, nature has its ways of determining the most effective path between the cloud that wants electrons and ground, which has an infinite supply of electrons (not really, but for the math, it works out to treat our planet as an infinite supply). That path will flow through the air to the ground for most of the Earth. That said, antennas connected to ground can offer a better choice. Last night, that choice was made with my antenna. When lightning strikes, damage happens.
My antenna is grounded, but some of the surge also went through the coax cable anyhow. I’m happy to report that all the signal goes through a small, $14.99 Maganovox 10 dB Signal Amplifier (model M61116). This unit helps make sure that I don’t lose signal strength at the point where the signal branches to 4 separate locations within the house. When the lightning struck last night, this little job sucked it up and died, protecting all my other equipment. I just purchased another 2 today-one as a replacement and one as a backup. Given that I’m spending $0/month for television access, I’m willing to incur this cost once in a while.
A question you might have is “How did Scott figure this out?” Basic troubleshooting came in handy. Trying to watch the news this morning showed no signal on any channel. Seeing that this was true on multiple TVs told me that a major part of the system was down (presented in order of effort to fix):
- No power to amplifier. Causes: circuit off because the switch was flipped or the circuit breaker was tripped. I checked the switch to the circuit and it was on. None of my breakers had tripped, so this wasn’t the cause. Had either of these been the cause, it would have been under 2 minutes from start to finish.
- Signal amplifier broken. Means I need to replace. With one on hand, it takes more time to setup, check, and replace. Should be a 20 minute job. Tools for me to check: one signal splitter, a ladder, and a helper to see if the TV shows a picture after running the test. Next time I run this test, I’ll bring up the replacement amplifier too, so I can finish the job quickly.
- Check for antenna damage: The only thing I can think of hear is maybe a case where the coax got ripped out of the antenna. The fix here is to replace the connector on the coax cable. Should take about 45 minutes to fix. Tools: wire stripper, coax connector, cable connector tool (either an electric drill or a crimping tool). Setup and cleanup are the killers on this one. Doing the work takes no time at all.
Any other problem would require research, so I hit these in terms of likelihood and ease of checking. None of the circuit breakers had tripped, so I went on to look at the amplifier. I went up to the attic and disconnected the antenna and the master bedroom from the amplifier. I joined those two over a splitter and checked out a normally strong signal (for me, this is WTMJ 4 out of Milwaukee). Since WTMJ came in, I knew where the problem was. I drove over to Menards, picked up the replacement amplifiers, and replaced the broken amplifier, reconnecting the antenna and master bedroom again. That continued to work, so I moved the remaining cables and was back in business.
Totally worth the frustration since I’m in control of when the TV comes back on, not Comcast/Time Warner, etc. And my cable is never out when some digging is going on.