Jack Gudenkauf (JackG) WebLog : Sample Code

Process Creation and Coordination

JackG — Tue, 12 Aug 2008 02:27:00 GMT

In some previous posts (Out of Process IPC/TCP Remoting code, .Net Remoting (AppDomains, Out of Process, Two Way, etc..)) I showed some sample code using .Net remoting over a process boundary. As a result, I received a few questions about the process creation and how to handle the process coordination (i.e., The Host/Master process waiting on the created process startup). I apologize to those who have been waiting for another sample on the subject, but I have been pretty busy as of late.

The attached sample code shows the following;

1. How to ensure the Host Process waits on the new process creation.

a. Previously I showed a simple *hack* where the created process sleeps for a while in order to let the process creation complete.

b. A much cleaner and more reliable solution uses EventWaitHandle.

2. The created Process runs until the Host Process is terminated or the Host terminates the new process.

a. Previously I showed a simple *hack* where the created process does a Console.ReadLine() in order to halt code execution and thus cause process termination.

b. I didn’t show an example of how the created process can shutdown in the event the Host process shuts down. This scenario covers orphaned processes.

c. The solution: System.Diagnostics.Process.GetProcessById(HostPID).WaitForExit();

View Source for Host Process: Show Code ...

View Source for Created Process: Show Code ...

Extensibility; Clients and Services calling each other

JackG — Mon, 10 Mar 2008 23:01:00 GMT

In this post I will be showing sample code (also found on our CodePlex site) as well as an execution sequence diagram. I will show sample code addressing some frequently asked questions; A Host calling AddIn services, AddIns calling (aka. Automation) a Host, AddIns calling AddIns, Managing AddIns (utilizing LINQ), which assemblies are loaded (Per AD and utilizing direct connect), etc…

1. A sample Host application that supports calls from the AddIn (aka., Automation) to the Host.

a. In the past we have shown the Host calling into the AddIn (Sample code), which happens naturally via System.AddIn activation of the AddIn. In other words, the activation of an AddIn allows the Host to call through to the AddIn.

b. We have shown the *pipeline* allowing the AddIn to automate the Host (Sample code).

i. As a result of several requests, this is a sample solution showing an end-to-end solution that includes the Host, Pipeline, and AddIn.

c. In the past I have shown sample code using pure remoting (i.e., No System.AddIn*) for two-way remoting / bi-directional calls (i.e., Host Automation) but now I will show the equivalent using MAF (i.e., Managed AddIn Framework).

2. I am including a Sequence diagram that ties to the Sample App source code showing;

a. AddIn Discovery, Qualification, Activation, AddIn calls into the Host (aka., Host Automation), AddIns requesting and calling other AddIn services (i.e., Client/Services).

3. Isolation - AppDomains and AddIns/Assemblies activated within each, understanding Activation optimization (i.e., Direct Connect forgoing Isolation), and unloadability (i.e., which assemblies/Types are loaded/unloadable).

4. Using LINQ to help you manage AddIns.

5. The benefits of having Adapters, whereby you have code running in the locality of an AppDomain. This is also an example aiding in understanding MarshalByRef (MBRO).

a. See List<string> GetASMInAppDomain(string AppDomainName) in HostHelper.cs for comments on the problem and the solution.

6. New features we included in the latest features we added to the VS2008 3.5 release.

a. Direct connect Optimization. We have received a few questions on this feature and as such I wanted to clarify the implementation.

i. You must enable DirectConnect

1. AddInToken.EnableDirectConnect = true;

ii. Our Activate method makes it easy to create an Add-in in a new AppDomain and as a result people are forgetting to pass in an existing AppDomain to the Activate method.

1. HAV = tokens[i].Activate<IAuthProvider>(AppDomain.CurrentDomain);

iii. Although we do not instantiate the Adapters we still require them to be defined in the pipeline folders. As some have pointed out, this may be counter-intuitive. We took this approach in order to guide you toward the right design (i.e., support for isolation and version resilience) going forward.

iv. Your Host view of AddIn and AddIn view of Host types respectively, must be the same type (i.e., in the same assembly).

1. In my sample code I list the assemblies in a selected AppDomain so you can see what is loaded. In the direct connect scenario you should not see the Adapter assemblies loaded in the AppDomain.

b. [ActivatableAs] Attribute enables AddIn side, View Type hierarchies.

i. I created an Abstract base class (ABC) as the Base for my views and I marked the ABC with our new attribute [ActivatableAs] which tells us which Base type is used for activating the Addin. The sample code shows how you can use Interfaces and Abstract Base Classes as views. This also shows some of the differences between versioning an Interface (which would require casting over time or Adapting) and an Abstract Base Class which allows a little more flexibility in versioning due to its ability to have default implementations. Note that the CLR does not support multiple inheritance so using Abstract Base Classes should be carefully considered.

c. Custom Qualification

i. Example of an Addin advertising its demand for activation in the Hosts default AppDomain. The Key/Value pair is nothing more than metadata you may use to suite any need your imagination allows.

d. FindAddIn

i. There are a number of scenarios where you may not have a clean directory structure for Add-in’s, or you may not have write access to the Add-in store, or you may not know the location of the Add-in until runtime (e.g., Click-Once deployed Add-in’s), etc..

e. AddIns calling AddIns

i. I will show one Add-in utilizing other AddIns that were instantiated by the Host. The AddIn consumer (Client) requests the List of other AddIns (Services) from the Host. This enables the AddIn to consume other services without having to do its own discovery and activation.

ii. This sample also shows the benefits of Adapter creation helper methods (AuthProviderHostAdapter) and the MAF support for passing Lists of reference types (CollectionAdapters.ToIListContract<> and CollectionAdapters.ToIListContract<>).

1. For more on Value and Reference type behavior, check out these posts by TQ

a. Are Arrays OK in Contracts?

b. Reference vs. Value: Types, Passing and Marshalling

7. Multiple Add-ins in a single Assembly

a. Although this isn’t a new feature, I am frequently asked about how assemblies and pipeline segments should be factored (more on this later) and confusion over Add-ins and Assemblies.

i. Check out the DefaultAuthProvider.cs as an example.

You asked for it (AddIn pipeline generator)

JackG — Fri, 11 Jan 2008 00:19:00 GMT

After all, our job is to make your life easier. I have received a *lot* of requests for a tool that can generate the Add-In pipeline segments. Ever since we mistakenly left comments in our MSDN articles code about the pipeline source being machine generated, some of you noticed that we may have been working on a tool. Soooooo, as a continuation of Microsoft's open and transparent developer experience (see this link for .Net framework source code, and this link to view/file bugs, receive early drops, etc..) we just released our pipeline generation tool source code to the community!!!

The tool generates source code as opposed to a binary (like tlbimp) so that you may alter the generated code. You may have specific naming conventions, or you would like to contribute to the tools functionality, so you can now do so via Codeplex. Here is a link to our Managed Extensibility and Add-In Framework source. We are also adding our sample code from our Add-in team Blog so that we a consolidated source (pun intended).

You can't say I didn't get you anything for Christmas. Have a great new year! JackG

Winforms, WPF and AppDomain isolation

JackG — Wed, 09 Jan 2008 21:55:00 GMT

We just posted a solution to consider for the F.A.Q. of how to enable isolatable WinForms applications. Check out this link. This solution may be considered relative to my previous post and subsequent comments. Note that WPF startup performance costs may be mitigated by applying the [LoaderOptimization(MultiDomainHost)] attribute to the main method. This tells the loader that the app expects to load multiple AppDomains with similar code and thus should share the assembly images (WPF NGen images) between AppDomains.

TechEd 2007 F.A.Q.

JackG — Tue, 13 Nov 2007 03:38:00 GMT

Hola!

I just returned from TechEd 2007 held in Barcelona, Spain. Barcelona is a beautiful city with incredible new and old architecture. The people are very friendly and even I was able to navigate the clean public transportation systems. Yes, I am one of those people that get lost easily and never stop to ask for directions. I was surprisingly given a beautiful suite overlooking the Mediterranean at the Hilton Diagonal Mar hotel right next to the convention center. I would highly recommend the hotel! Ask for a suite above the 15^thfloor in order to take advantage of the 15^th floor amenities!

I could go on and on about Barcelona, but I wanted to provide some links answering some of the F.A.Q.'s I received.

1. Does the Add-In model support UI extensibility via WPF? Yes, check out my Channel 9 video, as well as the sample code.

2. What is the state of Acropolis? Answer.

3. What about the PAG CAB (WPF and Acropolis)? Answer

4. Does the Add-In model support *in* domain activation, Click-once, custom meta-data, simple sandboxing, WPF isolation, and AddIn to AddIn communication? Yes, these features were added in the final Beta. Check out the “By popular demand link”.

5. Can you tell me more about the WPF Add-In support (e.g., XBAP)? Here is the WPF blog site link.

6. Where do I post WPF control specific Add-In questions? Here is a link.

7. Do you support Out of process activation and isolation of Add-Ins? Do you support Partial Trust Add-Ins in an external process? Can I have some control over the process? Yes, Yes, and Yes. Here is a link to some sample code showing how easy it is.

8. Can you tell me more about VSTA and the differences and/or reconciliation with the CLR Add-In model? Check out these links.

9. What are the rules/constraints of the types that may flow over the boundary? Here is a link to the contract constraints.

10. Where are the Add-In MSDN articles? Here are the links.

11. What about WinForms support? Who do I contact about this support? What about Crossbow? Check out these links and comments; WinForms and MAF link, Crossbow link.

12. Can you do Async programming in MAF? Yes, check out this link.

13. What about ill behaved Add-Ins and unhandled exceptions? Here is a link.

14. Do you have sample code showing Host automation and Events? Yes, check out this link.

15. Where do I get Add-In support? Here is a link.

16. Can you show me more pictures and less text? Can you tell more about the “Pipeline”? Can you show me some sample code for version tolerance, i.e., backward compatibility that supports something stronger than the use of a standard Interface or Abstract base class implementation. Here is a link for all the above questions.

17. Can the Add-In model be used as a dynamic component composition model? Yes! In some respects it was tragic that we used such a contextual naming convention of Host and Add-In, as opposed to component, composition, or automation. I will be posting a sample application that shows the new Beta2 features we added and you will see the basis for a component model within the sample, as well as some code answering another F.A.Q. about the management of components/Add-Ins. Stay tuned to this same bat channel.

If I missed one of your questions please let me know. For those that I met at the conference, thank you for your support and thoughtful questions as well as the positive feedback and strong session scores (the checks in the mail ;-)

And for those that know me, I did make it to the WPT Barcelona casino for poker. The stakes were a little high for my taste and the players were quite good, but I managed to do well. Playing with people from Israel, Spain, and Holland, to name a few, was a cultural experience I will never forget.

Gràcies, Gracias, Merci

.Net framework source code released

JackG — Wed, 03 Oct 2007 22:46:00 GMT

Recently I was speaking to a group of ISV's and Enterprise partners and as we spoke about the continued transparency of Microsoft, I vaguely mentioned more is coming. Well, here it is. ScottGu's blog post goes into the details of opening up our framework source code to the developer community.

Enjoy, JackG

Enumerating AppDomains

JackG — Mon, 11 Jun 2007 21:20:00 GMT

Recently I was writing a sample app showing some new MAF (Managed Add-In Framework) features that will be released very soon. Stay tuned.

As I was showing isolation and unload-ability, I wanted to enumerate the AppDomain's in the current process. Surprisingly there is no managed API in the BCL to show AppDomains L Using Interop however, we can list the AppDomains.

using System.Runtime.InteropServices; // for domain enum

using mscoree; // for domain enum. Add the following as a COM reference - C:\WINDOWS\Microsoft.NET\Framework\vXXXXXX\mscoree.tlb

namespace MyNS

{

public class ListProcessAppDomains

{

public static IList<AppDomain> GetAppDomains()

{

IList<AppDomain> _IList = new List<AppDomain>();

IntPtr enumHandle = IntPtr.Zero;

CorRuntimeHostClass host = new mscoree.CorRuntimeHostClass();

try

{

host.EnumDomains(out enumHandle);

object domain = null;

while (true)

{

host.NextDomain(enumHandle, out domain);

if (domain == null) break;

AppDomain appDomain = (AppDomain)domain;

_IList.Add(appDomain);

}

return _IList;

}

catch (Exception e)

{

Console.WriteLine(e.ToString());

return null;

}

finally

{

host.CloseEnum(enumHandle);

Marshal.ReleaseComObject(host);

}

Out of Process IPC/TCP Remoting code

JackG — Tue, 06 Mar 2007 01:21:00 GMT

Click this link for a description of the source code

I have attached the VS solutions in the file: SourceSolution.zip

View Source: Show Code ...

HostApp project – RemotingSamples Program.cs

.Net Remoting (AppDomains, Out of Process, Two Way, etc..)

JackG — Tue, 06 Mar 2007 01:17:00 GMT

I previously wrote about bi-directional remoting over IPC (see .Net Remoting continued and .Net Remoting). Several people asked for complete sample code. Ok, the squeaky wheel gets the attention. This could be an indication of my poor writing skills ;-) or the difficulty in figuring out remoting, or a little of both.

I also want to let you know that if you are a Host or ISV providing extensibility (in or out of process), I highly recommend utilizing the BCL’s Add-In model instead of rolling your own. Particularly, in lieu of using the sample app I am attaching. I left a lot of out!!! The code is more likely appropriate as an understanding of some principles or as an internal implementation (i.e., Not for 3^rd party extensibility). In the current Orcas CTP (I’ll post more on this) we have added out of process support to the System.AddIn BCL!!!

Two Way Communications

First, I want to let you know that in putting together this sample application I discovered I was wrong (don’t tell anyone) about the need to create another channel for handling incoming calls in addition to outgoing calls. Both IPC and TCP work with a single channel. Most of the issues had to do with that pesky typefilter. I guess none of the Indigo team members read my blog because no one corrected me. Hey, wait a minute. If no one noticed I was wrong and I corrected my mistake, I was only mistaken, not *wrong*.

I will show sample code of a remote object method invocation from a Host to a Remote app and vice versa. You may think in terms of a client and server if you wish, but I created so many samples that it became very confusing when an app worked like a client and a server, so I chose HostApp and RemoteApp as terms.

I also want the reader to know that a two way remoting method, whereby a Host instantiating an object, utilized for a remote process to call into and (i.e., not OR) vice versa is not a typical scenerio.

In a Host to Add-In model and in many other mainstream scenarios, the need to enable two-way method invocation in *both* the Server and Client is rare.

The typical way a “two-way” communication takes place is when one side (Client or Server) instantiates the others object and then uses that object to pass Serializable or MarshalByRef objects to the methods of the instantiated object. Or you instantiate a local, remotable object, that is called into from the remote application but rarely combinations of the two. In other words, the typical method employed is to instantiate (e.g., new) your object locally and as long as the object can be Marshaled, it is just passed to the remote client or server over an existing remoting channel via an objects method that takes the remotable object as a parameter. It may be hard to tell but I did try to make all that clear L I think the samples and the comments may make it clearer.

Sample code

· I have included an example of an IPC and TCP remoting channel.

· I used the Binary formatter since it is the most efficient.

· Notice the typefilter settings I blogged about.

· Remote method invocation may be accomplished in several ways

o via RemotingServices.Marshal // which is what I did in the sample

o via a config file and RemotingConfiguration.Configure(@"C:\blah \Client.exe.config", false); // I have prototyped this method successfully

o via RemotingConfiguration.RegisterWellKnownServiceType // I had issues with this method. Read as – Good luck with that.

· AppDomains

Check out a previous blog post on this subject
Remoting channels are only needed for Cross Process remote AppDomain communications. In process, cross AppDomain calls do not require a remoting channel.
You may not wish to run code in a remote processes default AppDomain. So I added a more complex example of a remote process, non-default AppDomain, since this is another tricky bit to work out when doing remoting. When running a “server/Host” In-process you don’t a channel per AppDomain, just a primary channel to handle incoming and outgoing calls. But for AppDomains in a remote process you need a channel per AppDomain for the calls.

The Source code may be found here.

Secret revealed

JackG — Thu, 01 Mar 2007 20:33:00 GMT

In a previous post (Extra, Extra – Read all about it!) I mentioned an upcoming highly requested feature. Well, it’s here. Last night we released the Visual Studio, code name “Orcas” March 2007 CTP. In this release you will find a number of VS, Language, and Platform features. And the System AddIn library has a new feature. We extended Add-in activation beyond AppDomains to support activating Add-In’s out of process! I will post more on the Add-In team blog about the feature (as well as a little refactoring of the code we did) but here is a little code snippet using the calculator sample from our MSDN articles, showing how simple it is to activate an Add-In out of process and some additional control you may attain as a Host using process isolation.

…

AddInToken calcToken = ChooseCalculator(tokens);

//Activate the selected AddInToken in a new AppDomain sandboxed in the internet zone

//Calculator calculator = calcToken.Activate<Calculator>(AddInSecurityLevel.Internet);

AddInProcess addInProcess = new AddInProcess();

Process HostProcess = Process.GetCurrentProcess();

System.Diagnostics.Trace.WriteLine("Calc Host PID: " + HostProcess.Id.ToString());

// The Process ID is -1 (i.e., Unassigned. Not yet created until Activate)

System.Diagnostics.Trace.WriteLine("addInProcess PID: " + addInProcess.ProcessId.ToString());

Calculator calculator = calcToken.Activate<Calculator>(addInProcess, AddInSecurityLevel.FullTrust);

// Get the AddinProcess created

Process tmpAddinProcess = Process.GetProcessById(addInProcess.ProcessId);

// Constrain the process WS

tmpAddinProcess.MaxWorkingSet = (IntPtr)((long)tmpAddinProcess.MaxWorkingSet - (long)tmpAddinProcess.MinWorkingSet / 2);

…

Where can I get the bits?

Use the following links for step-by-step instructions on installing and using the VPC images or installable bits.

.Net Remoting continued

JackG — Fri, 15 Dec 2006 02:14:00 GMT

After several frustrating hours troubleshooting issues with objects flowing in both directions (i.e., From Client to Sever and vice versa), I have some more information that may help you. This information is a continuation of the previous post on the subject found here.

In my previous posting I was primarily discussing activation of Client objects from a Server. I have also found something interesting about the communication between a Client and a Server over a remoting Channel, where a client object is accessed from a Server (i.e., not activated by the Server but proffered up from the Client to the Server over the remoting channel).

Is this confusing enough? Let’s use some pseudo-code to demonstrate the scenarios.

In the previous posting we spoke to the following scenerio.

A Host process (let’s call this the “Client”) creates a remoting channel (IPC, TCP)

BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();

BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();

System.Collections.IDictionary props = new System.Collections.Hashtable();

props["portName"] = “SomeName”;

ichannel = new IpcChannel(props, clientProvider, serverProvider);

…

The Host/Client starts another process (let’s call this the Server)

The Server application creates a remoting channel

…

ichannel = new IpcChannel(props, clientProvider, serverProvider);

…

The Server publishes a local MarshalByRefObject object (MBRO). Let’s call this ServerObject

RemotingServices.Marshal(ServerObject, @"UniqueIdentifier");

Or RegisterWellknownServiceType

The Client activates the ServerObject and makes calls on the methods

ServerObject serverObj = (ServerObject)Activator.GetObject(Type.GetType(AssemblyQualifiedNameOfObject), @"ipc://" + @"UniqueIdentifier"+ @"/ServerObject"));

serverObj.CallAMethod();

If the Sever wishes to activate a MBRO in the Client process we need the following;

The Client needs to create a server provider remoting channel
The Client needs to publishes a local MBRO. Let’s call this ClientObject.

The Server activates the ClientObject and now makes calls on the methods

In order to enable this two-way activation we need to set the typeFilterLevel to Full.

props["typeFilterLevel"] = "Full";

ichannel = new IpcChannel(props, clientProvider, serverProvider);

In the previous scenerio the Server can create MBRO’s and the Client can access the object methods over the channel. In a new scenerio, where the Client creates a MBRO object and attempts to pass the object to a Server Object, you will receive the following error message – “Because of security restrictions, the type System.Runtime.Remoting.ObjRef cannot be accessed.”

Note that this new scenerio the Server is not “activating” the Client object, but rather passing it to a Server object. Surprisingly, even though you have a channel established and you can call in one direction (Client calling on the Server), with an object that is MBRO, it fails. Doh!

We determined that we needed the typeFilterLevel property to be set to “Full” for the Server activating a Client object in the first scenerio. In this second scenerio, we also need to set the following;

serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

Go figure <shrug>

It is apparent that there is a difference between the

["typeFilterLevel"] = "Full" property

and

the Serverprovider setting

BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();

serverProvider.TypeFilterLevel = TypeFilterLevel.Full;

I am not sure why these seemingly similar settings behave differently, but they do. This may be a bug or intended behavior. If I receive an answer on why they differ, I will post my findings. In any event, I thought this might save someone else the frustration I experienced and also clear up my last posting where I insinuated that these settings are interchangeable. And besides, you now you have another two-way remoting scenerio to add to your bag of tricks.

.Net Remoting

JackG — Fri, 03 Nov 2006 05:15:00 GMT

I was recently writing some code that was simulating a Client application calling into a Server application across a process boundary. That is, the Client and Server application were running in different processes. I was prototyping some code where the Client was invoking a member on a MarshalByRef object provided by the Server over a tcp channel. After I finally worked out the remoting code for the Client to call multiple Server processes, I decided it would be a great feature to also allow the server call into the client. A two way (i.e., two-way, both directions, cooperative) remoting channel.

After searching high and low for a remoting solution, the best alternative I could come up with was to have the server return an object back to the client that the server could then call on. Although this is one method, it wasn’t at all what I had in mind.

Note that I was not using .config files for my channel providers, etc… Most examples of config file usage show the property that ultimately solved my issue (see below). The following may not be the best solution for you, but since I ran into the issue and had a hard time determining the solution, I thought I would share my findings.

In the Backwards breaking changes from version 1.0 to 1.1 list I found my answer. Title – Secure Serialization in .Net Remoting. By setting typeFilterLevel = “full” I was good to go. You can set this

via

…

System.Collections.IDictionary props = new System.Collections.Hashtable();

props["name"] = "Client";

props["typeFilterLevel"] = "Full";

…

Or via

…

BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();

serverProvider.TypeFilterLevel = TypeFilterLevel.Full;

…

Or via your App.exe.config setting

…

</serverProviders>

</channel>

</channels>

…

I hope this helps someone else out there. When dealing with remoting, may the force be with you ;-)

PInvoke, InterOp and Portability

JackG — Sat, 20 May 2006 02:31:00 GMT

I want to thank Josh Williams from the CLR team, for pointing out a couple bugs in my sample code. The bugs were related to some missing IntPtr’s for portability. For those interested in more information on Josh’s posts on 64-bit and PInvoke, check out Josh’s blog.

I have updated the sample code in my previous post "32/64bit sample code".

Josh also reminded me of a great Interop/PInvoke community Wiki I have been meaning to check out. The site was set up by Adam Nathan, one of (if not the) the foremost experts on InterOp. Check out Adam’s blog for more on this subject.

An ISV insight into the CLR and .Net framework 2.0 features

JackG — Tue, 25 Apr 2006 04:03:00 GMT

This was my first webcast, so please be patient through the beginning. It gets much better there after. Participants polled, thought so :-)

The primary theme of this webcast was to show how much the developer division has embraced the community through openness and solicitation of product feedback. It is our sincere desire to have the community driving product features, so please send me anonymous or non-anonymous feedback on this blog via comments or email.

The presentation covered the following Visual Studio 2005 subjects.

· Community

· SQL server integration

· 64bit

· Performance

· Stability

· Improved IDE

· Office programmability

I also touched on what's coming in the next two ISV webcast's.

· Visual Studio Tools for Applications description. Webcast.

· The WinFX Add-in model description. Webcast.

A description of the areas I showed in the webcast and sample code I demonstrated, may be found by clicking on the links below.

FTP, Console, Gzip compression sample code

I showed some v1.x code from an MSN application we wrote (Shuttle), were we utilized WebRequest functionality to roll our own FTP implementation. Although rich support for HTTP was provided in BCL 1.x over WebRequest and friends, FTP was not part of the BCL until 2.0.

This was an example of functionality a customer may write in their utility or helper classes that we could/should recommend for inclusion in the platform. It just so happens that I worked with the BCL team in building the MSN FTP implementation and the further inclusion into the CLR 2.0 product.

32/64bit sample code

· Sample code showing what platform (32/64bit) you are running on.

· Managed code can call into a native dll.

· Shows C# code making a Win32 dll call to open and read a file using a platform agnostic pointer.

· VS project properties

· Verifiable managed binaries just run on 64bit. See the platform target selection.

· Check the unsafe code, checkbox, for this sample code, since we are using the unsafe keyword for code that requires a pointer (a native code concept).

Network Information sample code

· Simple Ping

· ShowInterfaceSummary

· ShowTcpConnectionStatistics

· ShowInboundIPStatistics

Performance enhancements

· Leightweight Code Gen (LCG)

· Use the DynamicMethod class to generate and execute a method at run time without having to generate a dynamic assembly (AssemblyBuilder) and a dynamic type (DefineDynamicModule, DefineType)to contain the method. Dynamic methods are the most efficient way to generate and execute small amounts of code.

· TryParse

· I showed old code where I used RegEx (Regular Expressions) to validate if a string was an Int, Double, etc.. Value type.

· The good news was that the RegEx's I wrote in Perl just worked in .Net

· The bad news was that my performance characteristics for parsing large text files was suboptimal.

· I found that trying a convert the string to the type I expecting, was more performant, but programming by exception is a bad design pattern as exception overhead is costly.

· By using TryParse you can avoid exceptions and still validate the data type.

· This was an example of feedback we would like to receive on perfromance enhancements based upon your scenerio's.

· StopWatch

· A simple class used for timing.

· Another example of a utility class most people write themselves.

Leveraging the Platform

· I showed Office Programmability in the Visual Studio Tools for Office (VSTO) product where I wrote simple C# code behind an Excel Spreadsheet.

· I showed the IDE power of Hosting Excel as a designer in VS where I drag/drop a managed control onto the spreadsheet.

· I also used this simple example to show partial classes.

· A 2.0 feature that allows a class to span multiple physical files.

· In this example I showed ISV's how they could show simple user code for their developers in a partial class and hidden designer code in a separate file.

· I showed ENC where I stopped on a breakpoint, added code, and continued to run.

Performance enhancements (TryParse, LCG, StopWatch) sample code

JackG — Tue, 25 Apr 2006 03:56:00 GMT

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms; // msgbox

using System.Diagnostics; // Stopwatch

using System.Reflection; // LCG (Light Weight CodeGen)

using System.Reflection.Emit; // LCG (Light Weight CodeGen)

namespace Perf

{

class Program

{

static void Main(string[] args)

{

// Try-Parse

// @"^-?\d+$" Int, Smallint, TinyInt

TryandParse("ABC");

TryandParse("123");

TryandParse("123.12");

// StopWatch

Stopwatch stopWatch;

TimeSpan ts;

stopWatch = new Stopwatch();

String stringTimeFormat = "00:00:00.00";

stopWatch.Start();

ShowLCG();

stopWatch.Stop();

ts = stopWatch.Elapsed;

stringTimeFormat = String.Format("{0:00}:{1:00}:{2:00}:{3:00}",

ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds/10);

MessageBox.Show("Formated Elapsed Time\n" + stringTimeFormat + "\nElapsed milliseconds\n" + ts.Milliseconds, "StopWatch");

} // void Main

public static void TryandParse(string stringIn)

{

* Throwing exceptions can negatively impact performance.

try

{

Convert.ToInt32(stringIn);

}

catch (Exception e)

{

throw new ShuttleException(@"Invalid Int32, " + e.Message);

}

* For code that routinely fails, you can use design patterns to minimize performance issues.

bool DoesConvert = false;

int intValue = 0;

try

{

DoesConvert = Int32.TryParse(stringIn, out intValue); // does not throw

if (DoesConvert)

Trace.WriteLine(stringIn + ", String does convert to Int32");

else

Trace.WriteLine(stringIn + ", String does NOT convert to Int32");

}

catch (Exception e)

{

Console.WriteLine(e.Message);

}

} // TryandParse

public static void ShowLCG() // Lightweight Code Gen

{

/* DynamicMethod class is new in the .NET Framework version 2.0.

Use the DynamicMethod class to generate and execute a method at run time

without having to generate a dynamic assembly (AssemblyBuilder)

and a dynamic type (DefineDynamicModule, DefineType)to contain the method.

Dynamic methods are the most efficient way to generate and execute small amounts of code.

DynamicMethod dynamicMethod = new DynamicMethod("HelloISV" // Method name HelloISV

, typeof(void) // method void return type

, new Type[] { } // method parms

, typeof(Program) // Create the method in the class Program

, false);

// Get an ILGenerator and emit a body for the dynamic method,

// using a stream size larger than the IL that will be

// emitted.

ILGenerator iLGenerator = dynamicMethod.GetILGenerator(256);

// Load the first parameter, which is a string, onto the stack

iLGenerator.Emit(OpCodes.Ldstr, "Hello! ISV/VAR/SI");

// Call the Console.Writeline

iLGenerator.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));

iLGenerator.Emit(OpCodes.Ret); // returns from the current method

//Set next statement

//Console.WriteLine("ENC"); // Check Tools options, Debugging, ENC enabled.

dynamicMethod.Invoke(null, null); // Break point here

} // void ShowLCG()

} // class Program

} // namespace Perf