mfc car finance
My colleagues are using Visual Studio 2002 and uses the C++ MFC. I am developing in C #.
It has not been any problems before, but now questioning our customers if we really should develop in different environments. My colleagues think (of course) that I should move to C++ MFC. I think that they can use .NET instead of MFC.
Is there any point to learn the MFC? It feels a bit outmoded, or am I wrong? What are the arguments against and for .NET compared with MFC?
We are developing process systems and assistance applications for the nuclear industry. The main application is an emulator that emulates an old computer system and uses C++/MFC. It is very time critical, maybe the core should it still be in native C++. But the GUI to the emulator and all surrounding applications are not particularly critical.
And is there any real reason that you should replace the existing MFC application?
I’ve used both MFC and Windows Forms extensively for a very long time. I’m from the video game industry, so have had to write many desktop applications over the years, and before .net, MFC was extremely useful. Even before that I was writing tools in pure Win32.
MFC definitely had its quirks, but overall it made life a lot easier. It was very easy to integrate OpenGL and Direct3D into custom views, and once you got the hang of it writing custom controls was a piece of cake. Best of all, I could just code in pure C++, which just happened to be my language of choice. Plus I found MFC to be very efficient and snappy.
Gradually MFC started to get external control library support, particularly docking/toolbar libraries, so my tools like 3D model viewers and level editors, all looked pretty sweet.
Most applications I wrote created the UI programmatically, so the dialog/window layout tool was more than adequate for my needs.
MFC 9 is pretty cool too, especially with the Ribbon control/docking library that Microsoft has released as part of the Feature Pack. So there is life in the old dog yet, for sure! 🙂
When .net 1.0 came out I found the transition fairly easy, because it supported managed C++. It wasn’t pretty, but gave a relatively straightforward on-ramp to the .net framework. But the tipping point for me came when I started to write tools that needed the Windows Forms Designer more, around the time of .net 2.0. I decided to start again and learn C#, which I loved – although I’ll never get used to having new() without delete() ;). I then started writing user controls, finding the whole experience very nice and straightforward. The .net framework was huge, well supported, and generally I found it easier to do just about everything in C#/.net. Plus, compilation was lightning fast, and the ability to refactor in Visual Studio was awesome.
The beauty of c#/.net is it doesn’t limit you to just writing in managed code. You can still use unmanaged code, if performance is an issue for instance, or if you need to share code between platforms. For instance, my math libraries are written in C/C++, which I put into a libraries enabling C# to wrap/use the same code, although that’s only temporary. I’m going to port those libraries to C# in time too so everything is pure .net.
The last experience I want to mention is that I have been spending the last few months away from console game programming, and spending time programming the InterWeb. I’ve been using the Microsoft stack, programming in ASP.net/C#, and I have to say it’s very nice, with all of the knowledge of C# directly applicable. The only learning curve was ASP.net, not the language and support libraries. With the arrival of .net 3.5 (LINQ is sweet) life in the .net framework with C# is lovely.
Anyway, I don’t want to turn this into my life’s story, but I just wanted to give a brief experience of someone who has moved through all of the technology you’ve asked about. I’d also like to mention that it’s good for you to try different languages/frameworks. I’ve been coding for the iPhone for a year now, and have grown to really like Objective-C. It’s all programming, and it’s all good.
With respect to MFC/.net, both have their pluses and minuses, and I really don’t mind MFC at all, but in terms of moving forward, I’d probably stick to C#/.net, but please, please, please understand how it works. The only preachy thing I’ll say is to understand how memory in .net works, even though ‘it’s all taken care of for you’ 😉
Your knowledge of C/C++ should be completely independent of whether you use MFC or not, it’s still a critical language (particularly in console-based video game programming), but for desktop application programming on Windows, it’s getting harder and harder to argue against .net. It’s fast, easy, has great tool support, excellent 3rd party libraries, a huge growing community, is now cross platform (Mono) and will enable you to move between all current/emerging Microsoft technologies (ASP.net, WPF, Silverlight, WCF etc).
For all of this, though, I still set up Visual Studio as a C++ environment. Some habits never die 😉
MFC and .NET are at nearly opposite extremes, each thoroughly crappy in its own way.
Using MFC is roughly on the order of living in the decaying wreck of a WW II surplus building. There aren’t any signs to warn about dangerous areas, and it’s probably not immediately apparent where to find running water, electricity, or a toilet that works — even though all of them are there, if you know how to find them. Like any decaying building, there are plenty of holes in the walls and such, so you can leave anytime you want for as long as you want. Likewise, dragging in things from the outside world is pretty easy, though it’s pretty much up to you to do the “dragging” to get it there.
Using .NET is like living on the set of The Truman Show. It fits one person’s idea of what real life should be like. Within its boundaries, life can seem Utopian. In the end, however, it’s little more than a pleasantly accoutered prison cell, and none of what it portrays as life is quite real. All your interaction with the outside world is subject to the whim of a director whose aims are mostly to improve his own ratings; your welfare is considered only to the extent that it affects him.
Unlike most prisons, .NET does have a well marked escape route (labeled “P/Invoke”). Like the escape route from any good prison, however, it’s a mile-long sewage pipe. Most residents are aware of its existence, but nearly the only who go there are teenagers proving their manliness. The few who put it to real use do so only in dire necessity. Those of us who found it necessary once too often have realized it’s better to just stay outside and not go back in.
Edit: Since some people want circles and arrows and a paragraph on the back of each one to be used as evidence in court: MFC’s strength and weakness is that it’s mostly a fairly thin wrapper around the API. That’s a weakness because there are a fair number of holes in its coverage, and because it does relatively little to “smooth over” the places that the API itself doesn’t fit together particularly well. For example, if something is implemented using COM, that will usually show up directly in your code that uses it. It’s a strength, because it’s fairly easy to extend MFC to handle areas it doesn’t by default, as well as to simply bypass it and work directly with the API when you need to do so. It’s also been updated relatively infrequently, so while it can currently produce reasonably “modern” looking applications, that hasn’t always been the case. Given its history, it would be hard to predict that it’ll continue to be the case.
.NET’s strength and weakness is that it’s a much “thicker” wrapper around the API. It does considerably more to “smooth over” differences in the API, so (for example) parts that are implemented in COM don’t look/act noticeably different from parts that are implemented as straight C function calls. From inside .NET, the differences disappear. .NET is (currently) Microsoft’s favored technology, so it’s updated much more regularly, and does a much better job of ensuring that your UI follows the latest guidelines. My guess is that it’s much more likely than MFC to continue doing so for some time.
The weakness of .NET is that it’s much more difficult to bypass or extend. Basically, your only route to the outside world is through P/Invoke. Even for small excursions, it’s ugly and painful. Trying to use it very often or for anything approaching a major extension is an exercise in masochism.
If (nearly) everything you write can fit within what .NET supports, it’s the clear choice. It’s much cleaner and smoother as long as you stay inside its boundaries.
If you write code that fairly frequently needs to go outside the bounds supported by the framework, MFC will probably work much better for you. With .NET, the .NET model applies to your whole program. With MFC, it’s relatively easy to write programs that use MFC for their UI, and do things however they want for anything else that MFC doesn’t support.