You missed the “double” part of the double dispatch. The point of this pattern is to make sure that the right method of the processor is called – the method that accepts the right type. Since the processor is initially not aware of the type of the object that’s passed to it, you need the … Read more
To use Late binding, you should declare all your Outlook-specific objects as Object: Dim olApp As Object, olNamespace As Object, olFolder As Object, olConItems As Object Then: Set olApp = CreateObject(“Outlook.Application”) This will make each computer create the olApp object from the Outlook library that is installed on it. It avoids you to set an … Read more
In my experience of both high-performance software (e.g. games, number-crunching) and performance-neutral software (websites, most everything else), there’s been one huge advantage of late binding: the malleability/maintainability/extensibility you’ve mentioned. There’ve been two main benefits of early binding. The first: Runtime performance is commonly accepted, but generally irrelevant because in most cases it’s feasible to throw … Read more
You can, relativly, use late-binding IDispatch binding in C#. http://support.microsoft.com/kb/302902 Here’s some sample for using Excel. This way you don’t need to add a needless dependancy on Microsoft’s bloaty PIA: //Create XL Object xl = Activator.CreateInstance(Type.GetTypeFromProgID(“Excel.Application”)); //Get the workbooks collection. // books = xl.Workbooks; Object books = xl.GetType().InvokeMember( “Workbooks”, BindingFlags.GetProperty, null, xl, null); //Add a … Read more
It seems like not supporting Extension methods on Object was a design decision in VB. As a result, the only way we could prevent extension methods from completely breaking existing late bound code was to prevent them from being used on anything typed as object. Link
You’re looking for Marshal.GetActiveObject. object word; try { word = System.Runtime.InteropServices.Marshal.GetActiveObject(“Word.Application”); } catch (COMException) { Type type = Type.GetTypeFromProgID(“Word.Application”); word = System.Activator.CreateInstance(type); }
This is early binding: Dim olApp As Outlook.Application Set olApp = New Outlook.Application And this is late binding: Dim olApp As Object Set olApp = CreateObject(“Outlook.Application”) Late binding does not require a reference to Outlook Library 16.0 whereas early binding does. However, note that late binding is a bit slower and you won’t get intellisense … Read more
Yes! Option Strict is definitely a best practice with .Net. Emphasize that .Net is at it’s core a strongly typed platform, and will be until the DLR is more completely supported. With few exceptions, every Dim and Function should have an explicit type declared to go with it. Things like LINQ or Boo and JScript … Read more
They are different, because the value of i in both the generator expression and the list comp are evaluated lazily, i.e. when the anonymous functions are invoked in f. By that time, i is bound to the last value if t, which is -1. So basically, this is what the list comprehension does (likewise for … Read more
Everything is early bound in C# unless you go through the Reflection interface. Early bound just means the target method is found at compile time, and code is created that will call this. Whether its virtual or not (meaning there’s an extra step to find it at call time is irrelevant). If the method doesn’t … Read more