Prerequisites

Prerequisites for Learning MFC
https://msdn.microsoft.com/en-us/library/e4y1ezf5.aspx

Among the important assumptions made by the MFC documentation are that:

· You already know a little about programming for Windows.

· You know the basics of programming in C++.

· You understand the fundamentals of object-oriented programming.

Introduction

MFC is a SDK interface (wrapper) only, consisting in a set of classes that act as wrappers around the Win32 API, so that C++ programmers may program Windows using some concepts of the object-oriented programming (OOP) paradigm and the C++ language (the Win32 API is based on C). One should learn the Win32 API or at least have some ideas since some of the SDK functions are absent form the MFC and remember would help you better to understand the MFC.
https://en.wikipedia.org/wiki/Microsoft_Foundation_Class_Library
https://en.wikibooks.org/wiki/Windows_Programming/Introduction_to_MFC

Overview

Key MFC Programming Areas
https://msdn.microsoft.com/en-us/library/cys3kd51.aspx

Hierarchy Chart
https://msdn.microsoft.com/en-us/library/ws8s10w4.aspx

Learning Links

Creating an MFC Application
https://msdn.microsoft.com/en-us/library/9es9d1k4.aspx

Creating an MFC DLL Project
https://msdn.microsoft.com/en-us/library/wd5f0z40.aspx

Creating an MFC ActiveX Control
https://msdn.microsoft.com/en-us/library/yc13as7d.aspx

Walkthroughs (MFC Feature Pack)
https://msdn.microsoft.com/en-us/library/bb982451(VS.90).aspx

How do I videos

MFC Classes:
https://msdn.microsoft.com/en-us/visualc/bb496952.aspx#mfcclasses

MFC Feature Pack
https://msdn.microsoft.com/en-us/visualc/bb496952.aspx#mfcfeaturepack

MFC Samples

MSDN Samples:
https://msdn.microsoft.com/en-us/library/482ck6x8.aspx

FunctionX samples:
https://www.functionx.com/visualc/index.htm

FAQ

THE MFC FAQ version 1.3
https://ai.kaist.ac.kr/~ymkim/Program/mfc_faq.html

MSDN MVP:
https://vcfaq.mvps.org/mfc/index.htm

Walkthrough

Walkthroughs (MFC)
https://msdn.microsoft.com/en-us/library/bb982451.aspx

Forum

Visual C++
https://social.msdn.microsoft.com/Forums/en-US/category/visualc

VS 2010 New Feature

MFC Restart Manager Support in VS2010
https://blogs.msdn.com/vcblog/archive/2009/02/18/mfc-restart-manager.aspx

MFC applications now default to being DPI-aware
https://blogs.msdn.com/vcblog/archive/2010/03/11/mfc-applications-now-default-to-being-dpi-aware.aspx

CTaskDialog: an alternative to the simple message box!
https://blogs.msdn.com/vcblog/archive/2008/12/04/ctaskdialog-an-alternative-to-the-simple-message-box.aspx

System Requirement

.NET Framework

.NET Framework System Requirements

https://msdn.microsoft.com/en-us/library/8z6watww.aspx

Visual Studio .NET

Visual Studio .NET System Requirements

https://msdn.microsoft.com/en-us/library/4c26cc39(VS.71).aspx

Visual Studio 2005

Visual Studio 2005 System Requirements

https://msdn.microsoft.com/en-us/library/4c26cc39(VS.80).aspx

Visual Studio 2005 Team System Requirements

https://msdn.microsoft.com/en-us/library/ms252568(VS.80).aspx

Visual Studio 2008

Visual Studio 2008 System Requirements

https://msdn.microsoft.com/en-us/library/4c26cc39.aspx

See the readme file in the root directory of the Visual Studio 2008 installation media, or on the Internet at Readme: Visual Studio 2008.

Visual Studio 2008 Team System Requirements

https://msdn.microsoft.com/en-us/library/ms252568.aspx

Visual Studio 2010 System Requirements

Visual Studio 2010 Beta 1 Readme:

https://download.microsoft.com/download/7/A/0/7A023209-096F-4F7D-B2BC-831ECC68FF5B/VS2010Beta1Readme.htm

Visual Studio 2010 Beta 2 Readme:

https://download.microsoft.com/download/B/5/3/B5379D88-51D7-4240-9423-CE1427502784/VS2010Beta2Readme.htm

Visual Studio 2010 RC Readme:

https://download.microsoft.com/download/A/F/F/AFFE9A0D-E43C-4402-99C1-DD4E0E58AB60/VS2010RCReadme.htm

Best Practice to install Visual Studio

https://social.msdn.microsoft.com/forums/en-US/vssetup/thread/60f71a54-506e-4c70-be98-e993ce6d1ddf/

How to Troubleshoot

.NET Framework Troubleshooting

Unified .NET Framework Troubleshooting Guide

https://blogs.msdn.com/astebner/articles/454956.aspx

How to verify .NET Framework installation

https://social.msdn.microsoft.com/forums/en-US/netfxsetup/thread/f3f4a75b-9b7d-444d-aa4f-6c01d6f62f72#NET_Framework_verification

Visual Studio 2005 Troubleshooting

Visual Studio 2005 and .NET Framework 2.0 Setup Troubleshooting Guide

https://blogs.msdn.com/astebner/articles/492809.aspx

How to troubleshoot the installation of Visual Studio 2005

https://social.msdn.microsoft.com/forums/en-US/vssetup/thread/0376db8f-4761-4ae5-9af2-98c53216318a#How_to_troubleshoot_the_installation

Visual Studio 2008 Troubleshooting

What are the tips for troubleshooting Visual Studio 2008 setup problems?

https://social.msdn.microsoft.com/forums/en-US/vssetup/thread/0376db8f-4761-4ae5-9af2-98c53216318a#How_to_overcome_Visual_Studio_2008___

How to diagnose Visual Studio 2008 and .NET Framework 3.5 setup issues with setup Logs

https://social.msdn.microsoft.com/forums/en-US/vssetup/thread/0376db8f-4761-4ae5-9af2-98c53216318a#How_to_diagnoseVS2008_NETFramework_logs

Visual Studio 2008 Setup Troubleshooting Guide

https://blogs.msdn.com/varungupta/archive/2007/12/04/visual-studio-2008-setup-troubleshooting-guide.aspx

Visual Studio and .NET Framework Installation Tips

https://blogs.msdn.com/msdnforum/archive/2010/03/06/visual-studio-and-net-framework-installation-tips.aspx

Troubleshooting Tools

Collection Tool

https://blogs.msdn.com/heaths/archive/2008/05/09/visual-studio-and-net-log-collection-utility.aspx

.NET Framework Verification Tool

https://blogs.msdn.com/astebner/pages/8999004.aspx

.NET Framework Cleanup Tool

https://blogs.msdn.com/astebner/pages/8904493.aspx

Windows Installer CleanUp Utility

https://support.microsoft.com/kb/290301/en-us

Process Monitor

https://technet.microsoft.com/en-us/sysinternals/bb896645.aspx

How to troubleshoot

How to locate the cause of error code 1603 in a verbose MSI log file

https://blogs.msdn.com/astebner/archive/2005/08/01/446328.aspx

How to Interpret Windows Installer Logs

https://blogs.technet.com/richard_macdonald/archive/2007/04/02/How-to-Interpret-Windows-Installer-Logs.aspx

Common error code

Composite Installer is reporting 0x80070663

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/15ad04e8-1749-4eb4-bd09-4b5fd9f77d5f/

Error 5

https://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/ec14eb28-670d-446a-a83c-ad939025b15a

Error 87

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/c9d57fea-801b-4046-a626-89544dd3d190/?prof=required

Error 1304

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/c72e50cb-67b8-4e0f-8409-bdf472b43e22/

Error 1321

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/a2b272a7-ea99-4fef-ab33-929fd31e14d1/

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/69bf89a1-cd62-48d9-afd2-cac51cae480b/

Error 1330

https://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/9828a0cf-07db-47ff-8a72-998c2a0f31c2

Error 1402

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/9dcef871-1700-43c9-a168-4a52e60dfdcf/

Error 1601

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/e227dcb4-ebe5-4076-8957-6dd0807e7bdf

Error 1612

https://social.msdn.microsoft.com/Forums/en-SG/Vsexpressinstall/thread/b6ef62f7-adec-4b15-bf67-40697d09d660

Error 1714

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/a4a42d9c-80d3-4edb-9a4a-c352c5788cda

Error 1719

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/47985137-8766-4fc3-a42d-e0d8c4f2b4d5

Error 1935

https://blogs.msdn.com/astebner/archive/2004/11/10/255346.aspx

HRESULT 0x800736B3

https://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/b67f7676-99f8-4ca2-bcbc-9fbb4b5e2e46

HRESULT 0x8002802F

https://social.msdn.microsoft.com/Forums/en-US/netfxsetup/thread/48d600f7-70a0-4976-b7c6-31d28d44670b

HRESULT 0x80070002

https://blogs.msdn.com/astebner/archive/2005/02/01/364375.aspx

HRESULT 0x80070424

https://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/8dec5541-54ea-4d12-8a5c-37dba4db90f5

HRESULT 0x80070424

Error 2908

https://blogs.msdn.com/astebner/archive/2004/11/10/255346.aspx

Some Visual Studio command

How to remove Visual Studio

Remove .NET Framework

https://social.msdn.microsoft.com/forums/en-US/netfxsetup/thread/f3f4a75b-9b7d-444d-aa4f-6c01d6f62f72#How_to_remove_NET_framework

Remove Visual Studio 2005

https://support.microsoft.com/kb/907965/en-us

https://msdn.microsoft.com/en-us/library/ms246604(VS.80).aspx

Remove Visual Studio 2008

https://msdn.microsoft.com/en-us/library/ms246604.aspx

https://social.msdn.microsoft.com/Forums/en/vssetup/thread/0f8f41aa-a835-4f69-bc65-d9c563ff83a9

Hot Topics

Visual Studio 2010 Installation

Install VS in Windows 7

FAQ

Visual Studio Setup FAQ

https://social.msdn.microsoft.com/forums/en-US/vssetup/thread/0376db8f-4761-4ae5-9af2-98c53216318a

.NET Framework Setup FAQ

https://social.msdn.microsoft.com/forums/en-US/netfxsetup/thread/f3f4a75b-9b7d-444d-aa4f-6c01d6f62f72

Blog

Aaron Ruckman

https://blogs.msdn.com/aaronru/

Aaron Stebner

https://blogs.msdn.com/astebner/

Heath Stewart

https://blogs.msdn.com/heaths/

1. Right click Data Connection and select Add connection.
2. Input a Server name and select a database (you may need to wait for a few seconds when refreshing)

     3.    Open your Server Explorer, you’ll find you connection to the database.

Method one: Direct Database Debugging

1. Navigate to a Stored procedure in Server Explorer
2. Right click the stored procedure and select Step into Procedure

Method Two: Debug from SQL Server Project

1. Please first open Microsoft SQL Server Management Studio to make your database CLR Enabled. You need Open Database Query editor and execute the following statements:

  1: sp_configure 'show advanced options', 1;

  2: GO

  3: reconfigure;

  4: GO

  5: sp_configure 'clr enabled', 1;

  6: Go

  7: reconfigure;

    2.   Open your stored procedure. There is a Test Scripts folder, you could execute your stored procedure in script file  and then right click the script file and select Debug Script. There are two options here: You could set a breakpoint in Script file or in your .CS file. No matter where the breakpoint located, it will get hit.
NOTE: It is not support in VSTS2010 currently. You need to change that target .Net framework in project properties page. Also, you may encounter that deploy failed and require CLR Enable message in Output window, please make sure you run the script code in Step 1.

Method three: Debug by attaching to other processes

This is not much like attaching to other processes, one thing may be taken into account is to select the T-SQL code type in the Attach to Processes dialog box

The SQL CLR Integration team has an excellent blog introducing these three ways briefly here.

Introduction

While you can write applications entirely in either managed or native code, it is possible to mix managed and native projects in the same solution. So this article lists the methods about interop with native C++.

Invoke .NET Assembly from Native C++ Code

1. Hosting API. Native VC++ module calls CLR Hosting APIs to host CLR, load and call the .NET assembly.

2. COM interop . If the .NET assembly can be exposed as a COM component, native VC++ module can call into the .NET assembly through .NET .

3. Reverse PInvoke. The managed code call native passing a delegate the native code can call back.

4. IJW. If the module containing native VC++ code is allowed to enable CLR, the native VC++ code can call .NET assembly directly through the “It Just Works”, or “IJW”, mechanism.

Invoke Native C++ DLL from .NET code

1. IJW or It Just Works. This is one of the greatest features that .NET Framework has provided to developers. You just recompile the old code on the new .NET platform. No or little changes are necessary. Don't forget though; it works in the C++ language only.

2. COM. The COM model works on both the unmanaged and managed environments. It's straightforward to perform a COM Invoke on .NET. But, if your unmanaged classes are not COM-ready, you probably won't rewrite all the old code to support COM.

3. P/Invoke or Platform Invoke. This mechanism allows you to import a class as functions at the attribute level. Basically, you import class methods one by one as individual functions, as you do with Win32 APIs.

Samples:

Microsoft All-In-One Code Framework has working examples that demonstrate the methods.

Invoke Native C++ DLL from .NET Code

https://1code.codeplex.com/wikipage?title=Invoke%20Native%20C%2b%2b%20DLL%20from%20.NET&referringTitle=Documentation

Invoke .NET Assembly from Native C++ Code

https://1code.codeplex.com/wikipage?title=Invoke%20.NET%20Assembly%20from%20Native%20C%2b%2b&referringTitle=Documentation

Learning Links:

Interop (How Do I in Visual C++)

https://msdn.microsoft.com/en-us/library/ms177552%28VS.90%29.aspx

Best Practices For Managed And Native Code Interoperability

https://msdn.microsoft.com/en-us/magazine/dd315414.aspx

Using Unmanaged C++ Libraries (DLLs) in .NET Applications

https://www.codeproject.com/KB/mcpp/usingcppdll.aspx

Managed/Native Code Interoperability

https://msdn.microsoft.com/en-us/library/bb677136.aspx

We first create an EDM with two entities: Department and Course.

Lazy Loading

Right click any blank area of the EDM designer, we see the ConceptualEntityModel properties of the EDM. Among the properties, there is one property named Lazy Loading Enabled which is by default set to True.

With Lazy Loading Enabled, the constructors of our ObjecConntext look like:

  1:     /// <summary>

  2:     /// Initializes a new LazyLoadingEntities object using 

  3:     /// the connection string found in the 'LazyLoadingEntities'

  4:     ///  section of the application configuration file.

  5:     /// </summary>

  6:     public LazyLoadingEntities() : 

  7:     base("name=LazyLoadingEntities", "LazyLoadingEntities")

  8:     {

  9:         this.ContextOptions.LazyLoadingEnabled = true;
 10:         OnContextCreated();

 11:     }

 12: 

Let’s see how Lazy Loading works.

  1:     using (LazyLoadingEntities context = new LazyLoadingEntities())

  2:     {

  3:     // Lazy loading is enabled dy default in EF4, so turn it off 

  4:     // to use eager loading later

  5:         context.ContextOptions.LazyLoadingEnabled = false;

  7:     // Query the department entities which Budget is not NULL

  8:     // Here we use the .Include() method to eager load the related

  9:     // course entities

 10:         var departments = from d in context.Departments.Include("Courses")

 11:         where d.Budget != null

 12:         select d;

 13:         foreach (var department in departments)

 14:         {

 15:             Console.WriteLine("Department: {0}", department.Name);

 16:             Console.WriteLine("Courses:");

 17:     // The related course entities has been already loaded

 18:     // Note: for eager loading, there will be only one

 19:     // database call to load the department and corresponding 

 20:     // course entities

 21:             foreach (var course in department.Courses)

 22:             {

 23:                 Console.WriteLine(course.Title);

 24:             }

 26:             Console.WriteLine();

 27:         }

 28:     }

For the sake of this example, assume that we have 5 departments and 10 courses for 4 departments among the 5 departments. From the query results in the SQL Server Profiler, there is 1 query to retrieve the Departments and 4 individual queries for each of the 4 Departments.

Last week, I heard that IntelliTrace in VS2010 Ultimate can also trace the SQL execution of our application, like the following image indicates.

Eager Loading

Eager Loading is implemented by the Include method which specifies the related objects to include in the query results. To use Eager Loading in EF4, we need to turn of the default Lazy Loading by setting the Lazy Loading Enabled property to False or programmatically set the ObjectContextOptions.LazyLoadingEnabled = false.

Let’s see how Eager Loading works.

  1:     using (LazyLoadingEntities context = new LazyLoadingEntities())

  2:     {

  3:     // Lazy loading is enabled dy default in EF4, so turn it off 

  4:     // to use eager loading later

  5:         context.ContextOptions.LazyLoadingEnabled = false;

  6: 

  7:     // Query the department entities which Budget is not NULL

  8:     // Here we use the .Include() method to eager load the related

  9:     // course entities

 10:         var departments = from d in context.Departments.Include("Courses")

 11:         where d.Budget != null

 12:         select d;

 13:         foreach (var department in departments)

 14:         {

 15:             Console.WriteLine("Department: {0}", department.Name);

 16:             Console.WriteLine("Courses:");

 17:     // The related course entities has been already loaded

 18:     // Note: for eager loading, there will be only one

 19:     // database call to load the department and corresponding

 20:     // course entities

 21:             foreach (var course in department.Courses)

 22:             {

 23:                 Console.WriteLine(course.Title);

 24:             }

 25:             Console.WriteLine();

 26:         }

 27:     }

From the SQL commands tracked in SQL Server Profiler, only 1 query is executed to retrieve all the related Departments and Courses.

Trace result in IntelliTrace:

Explicit Loading Explicit Loading is implemented by calling EntityCollection.Load or EntityReference.Load to retrieve the related entities. Similar with the Eager Loading, we need to turn off the default Lazy Loading in EF4.

  1:     using (LazyLoadingEntities context = new LazyLoadingEntities())

  2:     {

  3:     // Lazy loading is enabled dy default in EF4, so turn it off 

  4:     // to use explicit loading later

  5:         context.ContextOptions.LazyLoadingEnabled = false;

  6:     // Query the department entities which Budget is not NULL

  7:         var departments = from d in context.Departments

  8:                           where d.Budget != null

  9:         select d;

 10:         foreach (var department in departments)

 11:         {

 12:             Console.WriteLine("Department: {0}", department.Name);

 13:             Console.WriteLine("Courses:");

 14:     // Explicit load the related courses entities if they

 15:     // are not loaded yet

 16:     // Note: here for each department, there will be a 

 17:     // seperate database call to load the course entities

 18:             if (!department.Courses.IsLoaded)

 19:             {

 20:                 department.Courses.Load();

 21:             }

 22:             foreach (var course in department.Courses)

 23:             {

 24:                 Console.WriteLine(course.Title);

 25:             }

 26:             Console.WriteLine();

 27:         }

 28:     }

 29: 

The SQL commands that are executed here are similar with what we saw in the Lazy Loading test.

Discussion

Actually, I think Lazy Loading, Eager Loading and Explicit Loading are for different scenarios. Lazy Loading and Explicit Loading are in one kind while Eager Loading is the opposite. EF4 helps us to implement the Explicit Loading logic to retrieve the related entities if necessary, which becomes Lazy Loading. So I believe Lazy Loading and Explicit Loading offer the same performance benefits and challenges. For the Eager Loading, the benefit is that we only use one query to get all the related entities, which means only one database connection and one network trip are needed here. However, the single resultset can be really large and the single query structure can be very complicated and expensive (with many JOINs).

Like the folks who support Lazy Loading, I second that it should be a feature of an ORM. I am very glad to see that Lazy Loading is now implemented in EF4, because it makes the entity world more flexible. J

All the sample codes in this post can be found in the samples CSEFLazyLoading (C#) and VBEFLazyLoading (VB.NET) in All-In-One Code Framework which is an open-source project delineating the framework and skeleton of Microsoft development techniques.

Additional references

Loading Related Objects (Entity Framework) https://msdn.microsoft.com/en-us/library/bb896272.aspx

How to: Use Lazy Loading to Load Related Objects (Entity Framework) https://msdn.microsoft.com/en-us/library/dd456846.aspx

How to: Use Query Paths to Shape Results (Entity Framework) https://msdn.microsoft.com/en-us/library/bb738449.aspx

How to: Explicitly Load Related Objects (Entity Framework) https://msdn.microsoft.com/en-us/library/bb896249.aspx

The Common Language Runtime (CLR) allows a level of integration between itself and a host. This article is about a C++ code sample that demonstrates using the Hosting Interfaces of .NET Framework 4.0 to host a specific version of CLR in the process, load a .NET assembly, and invoke the types in the assembly. The code sample also demonstrates the new In-Process Side-by-Side feature in .NET Framework 4. The .NET Framework 4 runtime, and all future runtimes, are able to run in-process with one another. .NET Framework 4 runtime and beyond are also able to run in-process with any single older runtime. In ther words, you will be able to load 4, 5 and 2.0 in the same process, but you will not be able to load 1.1 and 2.0 in the same process. The code sample hosts .NET runtime 4.0 and 2.0 side by side, and loads a .NET 2.0 assembly into the two runtimes.

The code sample in this article (CppHostCLR) can be downloaded from Microsoft All-In-One Code Framework, which is a centralized code sample library.

The following steps walk through a demonstration of the CLR Hosting sample.

Step1. After you successfully build the sample project, and the dependent .NET class library projects (CSClassLibrary and CSNET2ClassLibrary) in Visual Studio 2010, you will get an application and two libraries: CppHostCLR.exe, CSClassLibrary.dll, and CSNET2ClassLibrary.dll. Make sure that the files are in the same folder.

Step2. Run the application in a command prompt. The application demonstrates the CLR In-Process Side-by-Side feature that is new in .NET 4 first. It hosts the .NET runtime 4.0 first and loads a .NET 2.0 assembly into the runtime to invoke its types. Then the application hosts the .NET runtime 2.0 side by side with the .NET runtime 4.0 and loads the same .NET 2.0 assembly into the .NET 4.0 runtime. If the operations succeed, the application prints the
following content in the console.

    Load and start the .NET runtime v4.0.30319
    Load the assembly CSNET2ClassLibrary
    Call CSNET2ClassLibrary.CSSimpleObject.GetStringLength("HelloWorld") => 10
    Call CSNET2ClassLibrary.CSSimpleObject.ToString() => 0.00

    Load and start the .NET runtime v2.0.50727
    Load the assembly CSNET2ClassLibrary
    Call CSNET2ClassLibrary.CSSimpleObject.GetStringLength("HelloWorld") => 10
    Call CSNET2ClassLibrary.CSSimpleObject.ToString() => 0.00

    Presss ENTER to continue ...

You can verify that both .NET 2.0 and .NET 4.0 runtimes are loaded by using Process Explorer (https://technet.microsoft.com/en-us/sysinternals/bb896653.aspx). In Lower Pane View / DLLs of the tool, you can see all modules loaded in the process. If clr.dll (the .NET 4 runtime module) and mscorwks.dll (the .NET 2 runtime module) are in the list, both .NET 2.0 and .NET 4.0 runtimes are loaded.

Step3. Press ENTER to continue. The application will host the .NET runtime 4.0 and use the ICLRRuntimeHost interface that was provided in .NET v2.0 to
load a .NET 4.0 assembly and invoke its type.

    Load and start the .NET runtime v4.0.30319
    Load the assembly CSClassLibrary.dll
    Call CSClassLibrary.CSSimpleObject.GetStringLength("HelloWorld") => 10

The key code in the code sample is attached below.

  1: //

  2: //   FUNCTION: RuntimeHostV4Demo1(PCWSTR, PCWSTR)

  3: //

  4: //   PURPOSE: The function demonstrates using .NET Framework 4.0 Hosting 

  5: //   Interfaces to host a .NET runtime, and use the ICorRuntimeHost interface

  6: //   that was provided in .NET v1.x to load a .NET assembly and invoke its 

  7: //   type. 

  8: //   

  9: //   If the .NET runtime specified by the pszVersion parameter cannot be 

 10: //   loaded into the current process, the function prints ".NET runtime <the 

 11: //   runtime version> cannot be loaded", and return.

 12: //   

 13: //   If the .NET runtime is successfully loaded, the function loads the 

 14: //   assembly identified by the pszAssemblyName parameter. Next, the function 

 15: //   instantiates the class (pszClassName) in the assembly, calls its 

 16: //   ToString() member method, and print the result. Last, the demo invokes 

 17: //   the public static function 'int GetStringLength(string str)' of the class 

 18: //   and print the result too.

 19: //

 20: //   PARAMETERS:

 21: //   * pszVersion - The desired DOTNETFX version, in the format “vX.X.XXXXX”. 

 22: //     The parameter must not be NULL. It’s important to note that this 

 23: //     parameter should match exactly the directory names for each version of

 24: //     the framework, under C:\Windows\Microsoft.NET\Framework[64]. The 

 25: //     current possible values are "v1.0.3705", "v1.1.4322", "v2.0.50727" and 

 26: //     "v4.0.30319". Also, note that the “v” prefix is mandatory.

 27: //   * pszAssemblyName - The display name of the assembly to be loaded, such 

 28: //     as "CSClassLibrary". The ".DLL" file extension is not appended.

 29: //   * pszClassName - The name of the Type that defines the method to invoke.

 30: //

 31: //   RETURN VALUE: HRESULT of the demo.

 32: //

 33: HRESULT RuntimeHostV4Demo1(PCWSTR pszVersion, PCWSTR pszAssemblyName, 

 34:     PCWSTR pszClassName)

 35: {

 36:     HRESULT hr;

 37:     ICLRMetaHost *pMetaHost = NULL;

 38:     ICLRRuntimeInfo *pRuntimeInfo = NULL;

 39:     // ICorRuntimeHost and ICLRRuntimeHost are the two CLR hosting interfaces

 40:     // supported by CLR 4.0. Here we demo the ICorRuntimeHost interface that 

 41:     // was provided in .NET v1.x, and is compatible with all .NET Frameworks. 

 42:     ICorRuntimeHost *pCorRuntimeHost = NULL;

 43:     IUnknownPtr spAppDomainThunk = NULL;

 44:     _AppDomainPtr spDefaultAppDomain = NULL;

 45:     // The .NET assembly to load.

 46:     bstr_t bstrAssemblyName(pszAssemblyName);

 47:     _AssemblyPtr spAssembly = NULL;

 48:     // The .NET class to instantiate.

 49:     bstr_t bstrClassName(pszClassName);

 50:     _TypePtr spType = NULL;

 51:     variant_t vtObject;

 52:     variant_t vtEmpty;

 53:     // The static method in the .NET class to invoke.

 54:     bstr_t bstrStaticMethodName(L"GetStringLength");

 55:     SAFEARRAY *psaStaticMethodArgs = NULL;

 56:     variant_t vtStringArg(L"HelloWorld");

 57:     variant_t vtLengthRet;

 58:     // The instance method in the .NET class to invoke.

 59:     bstr_t bstrMethodName(L"ToString");

 60:     SAFEARRAY *psaMethodArgs = NULL;

 61:     variant_t vtStringRet;

 62:     // 

 63:     // Load and start the .NET runtime.

 64:     // 

 65:     wprintf(L"Load and start the .NET runtime %s \n", pszVersion);

 66:     hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_PPV_ARGS(&pMetaHost));

 67:     if (FAILED(hr))

 68:     {

 69:         wprintf(L"CLRCreateInstance failed w/hr 0x%08lx\n", hr);

 70:         goto Cleanup;

 71:     }

 72:     // Get the ICLRRuntimeInfo corresponding to a particular CLR version. It 

 73:     // supersedes CorBindToRuntimeEx with STARTUP_LOADER_SAFEMODE.

 74:     hr = pMetaHost->GetRuntime(pszVersion, IID_PPV_ARGS(&pRuntimeInfo));

 75:     if (FAILED(hr))

 76:     {

 77:         wprintf(L"ICLRMetaHost::GetRuntime failed w/hr 0x%08lx\n", hr);

 78:         goto Cleanup;

 79:     }

 80:     // Check if the specified runtime can be loaded into the process. This 

 81:     // method will take into account other runtimes that may already be 

 82:     // loaded into the process and set pbLoadable to TRUE if this runtime can 

 83:     // be loaded in an in-process side-by-side fashion. 

 84:     BOOL fLoadable;

 85:     hr = pRuntimeInfo->IsLoadable(&fLoadable);

 86:     if (FAILED(hr))

 87:     {

 88:         wprintf(L"ICLRRuntimeInfo::IsLoadable failed w/hr 0x%08lx\n", hr);

 89:         goto Cleanup;

 90:     }

 91:     if (!fLoadable)

 92:     {

 93:         wprintf(L".NET runtime %s cannot be loaded\n", pszVersion);

 94:         goto Cleanup;

 95:     }

 96:     // Load the CLR into the current process and return a runtime interface 

 97:     // pointer. ICorRuntimeHost and ICLRRuntimeHost are the two CLR hosting  

 98:     // interfaces supported by CLR 4.0. Here we demo the ICorRuntimeHost 

 99:     // interface that was provided in .NET v1.x, and is compatible with all 

100:     // .NET Frameworks. 

101:     hr = pRuntimeInfo->GetInterface(CLSID_CorRuntimeHost,

102:          IID_PPV_ARGS(&pCorRuntimeHost));

103:     if (FAILED(hr))

104:     {

105:         wprintf(L"ICLRRuntimeInfo::GetInterface failed w/hr 0x%08lx\n", hr);

106:         goto Cleanup;

107:     }

108:     // Start the CLR.

109:     hr = pCorRuntimeHost->Start();

110:     if (FAILED(hr))

111:     {

112:         wprintf(L"CLR failed to start w/hr 0x%08lx\n", hr);

113:         goto Cleanup;

114:     }

115:     // 

116:     // Load the NET assembly. Call the static method GetStringLength of the 

117:     // class CSSimpleObject. Instantiate the class CSSimpleObject and call 

118:     // its instance method ToString.

119:     // 

120:     // The following C++ code does the same thing as this C# code:

121:     // 

122:     //   Assembly assembly = AppDomain.CurrentDomain.Load(pszAssemblyName);

123:     //   object length = type.InvokeMember("GetStringLength", 

124:     //       BindingFlags.InvokeMethod | BindingFlags.Static | 

125:     //       BindingFlags.Public, null, null, new object[] { "HelloWorld" });

126:     //   object obj = assembly.CreateInstance("CSClassLibrary.CSSimpleObject");

127:     //   object str = type.InvokeMember("ToString", 

128:     //       BindingFlags.InvokeMethod | BindingFlags.Instance | 

129:     //       BindingFlags.Public, null, obj, new object[] { });

130:     // Get a pointer to the default AppDomain in the CLR.

131:     hr = pCorRuntimeHost->GetDefaultDomain(&spAppDomainThunk);

132:     if (FAILED(hr))

133:     {

134:         wprintf(L"ICorRuntimeHost::GetDefaultDomain failed w/hr 0x%08lx\n", hr);

135:         goto Cleanup;

136:     }

137:     hr = spAppDomainThunk->QueryInterface(IID_PPV_ARGS(&spDefaultAppDomain));

138:     if (FAILED(hr))

139:     {

140:         wprintf(L"Failed to get default AppDomain w/hr 0x%08lx\n", hr);

141:         goto Cleanup;

142:     }

143:     // Load the .NET assembly.

144:     wprintf(L"Load the assembly %s\n", pszAssemblyName);

145:     hr = spDefaultAppDomain->Load_2(bstrAssemblyName, &spAssembly);

146:     if (FAILED(hr))

147:     {

148:         wprintf(L"Failed to load the assembly w/hr 0x%08lx\n", hr);

149:         goto Cleanup;

150:     }

151:     // Get the Type of CSSimpleObject.

152:     hr = spAssembly->GetType_2(bstrClassName, &spType);

153:     if (FAILED(hr))

154:     {

155:         wprintf(L"Failed to get the Type interface w/hr 0x%08lx\n", hr);

156:         goto Cleanup;

157:     }

158:     // Call the static method of the class: 

159:     //   public static int GetStringLength(string str);

160:     // Create a safe array to contain the arguments of the method. The safe 

161:     // array must be created with vt = VT_VARIANT because .NET reflection 

162:     // expects an array of Object - VT_VARIANT. There is only one argument, 

163:     // so cElements = 1.

164:     psaStaticMethodArgs = SafeArrayCreateVector(VT_VARIANT, 0, 1);

165:     LONG index = 0;

166:     hr = SafeArrayPutElement(psaStaticMethodArgs, &index, &vtStringArg);

167:     if (FAILED(hr))

168:     {

169:         wprintf(L"SafeArrayPutElement failed w/hr 0x%08lx\n", hr);

170:         goto Cleanup;

171:     }

172:     // Invoke the "GetStringLength" method from the Type interface.

173:     hr = spType->InvokeMember_3(bstrStaticMethodName, static_cast<BindingFlags>(

174:         BindingFlags_InvokeMethod | BindingFlags_Static | BindingFlags_Public), 

175:         NULL, vtEmpty, psaStaticMethodArgs, &vtLengthRet);

176:     if (FAILED(hr))

177:     {

178:         wprintf(L"Failed to invoke GetStringLength w/hr 0x%08lx\n", hr);

179:         goto Cleanup;

180:     }

181:     // Print the call result of the static method.

182:     wprintf(L"Call %s.%s(\"%s\") => %d\n", 

183:         static_cast<PCWSTR>(bstrClassName), 

184:         static_cast<PCWSTR>(bstrStaticMethodName), 

185:         static_cast<PCWSTR>(vtStringArg.bstrVal), 

186:         vtLengthRet.lVal);

187:     // Instantiate the class.

188:     hr = spAssembly->CreateInstance(bstrClassName, &vtObject);

189:     if (FAILED(hr))

190:     {

191:         wprintf(L"Assembly::CreateInstance failed w/hr 0x%08lx\n", hr);

192:         goto Cleanup;

193:     }

194:     // Call the instance method of the class.

195:     //   public string ToString();

196:     // Create a safe array to contain the arguments of the method.

197:     psaMethodArgs = SafeArrayCreateVector(VT_VARIANT, 0, 0);

198:     // Invoke the "ToString" method from the Type interface.

199:     hr = spType->InvokeMember_3(bstrMethodName, static_cast<BindingFlags>(

200:         BindingFlags_InvokeMethod | BindingFlags_Instance | BindingFlags_Public),

201:         NULL, vtObject, psaMethodArgs, &vtStringRet);

202:     if (FAILED(hr))

203:     {

204:         wprintf(L"Failed to invoke ToString w/hr 0x%08lx\n", hr);

205:         goto Cleanup;

206:     }

207:     // Print the call result of the method.

208:     wprintf(L"Call %s.%s() => %s\n", 

209:         static_cast<PCWSTR>(bstrClassName), 

210:         static_cast<PCWSTR>(bstrMethodName), 

211:         static_cast<PCWSTR>(vtStringRet.bstrVal));

212: Cleanup:

213:     if (pMetaHost)

214:     {

215:         pMetaHost->Release();

216:         pMetaHost = NULL;

217:     }

218:     if (pRuntimeInfo)

219:     {

220:         pRuntimeInfo->Release();

221:         pRuntimeInfo = NULL;

222:     }

223:     if (pCorRuntimeHost)

224:     {

225:         // Please note that after a call to Stop, the CLR cannot be 

226:         // reinitialized into the same process. This step is usually not 

227:         // necessary. You can leave the .NET runtime loaded in your process.

228:         //wprintf(L"Stop the .NET runtime\n");

229:         //pCorRuntimeHost->Stop();

230:         pCorRuntimeHost->Release();

231:         pCorRuntimeHost = NULL;

232:     }

233:     if (psaStaticMethodArgs)

234:     {

235:         SafeArrayDestroy(psaStaticMethodArgs);

236:         psaStaticMethodArgs = NULL;

237:     }

238:     if (psaMethodArgs)

239:     {

240:         SafeArrayDestroy(psaMethodArgs);

241:         psaMethodArgs = NULL;

242:     }

243:     return hr;

244: }

245: 

246: //

247: //   FUNCTION: RuntimeHostV4Demo2(PCWSTR, PCWSTR)

248: //

249: //   PURPOSE: The function demonstrates using .NET Framework 4.0 Hosting 

250: //   Interfaces to host a .NET runtime, and use the ICLRRuntimeHost interface

251: //   that was provided in .NET v2.0 to load a .NET assembly and invoke its 

252: //   type. Because ICLRRuntimeHost is not compatible with .NET runtime v1.x, 

253: //   the requested runtime must not be v1.x.

254: //   

255: //   If the .NET runtime specified by the pszVersion parameter cannot be 

256: //   loaded into the current process, the function prints ".NET runtime <the 

257: //   runtime version> cannot be loaded", and return.

258: //   

259: //   If the .NET runtime is successfully loaded, the function loads the 

260: //   assembly identified by the pszAssemblyName parameter. Next, the function 

261: //   invokes the public static function 'int GetStringLength(string str)' of 

262: //   the class and print the result.

263: //

264: //   PARAMETERS:

265: //   * pszVersion - The desired DOTNETFX version, in the format “vX.X.XXXXX”. 

266: //     The parameter must not be NULL. It’s important to note that this 

267: //     parameter should match exactly the directory names for each version of

268: //     the framework, under C:\Windows\Microsoft.NET\Framework[64]. Because 

269: //     the ICLRRuntimeHost interface does not support the .NET v1.x runtimes, 

270: //     the current possible values of the parameter are "v2.0.50727" and 

271: //     "v4.0.30319". Also, note that the “v” prefix is mandatory.

272: //   * pszAssemblyPath - The path to the Assembly to be loaded.

273: //   * pszClassName - The name of the Type that defines the method to invoke.

274: //

275: //   RETURN VALUE: HRESULT of the demo.

276: //

277: HRESULT RuntimeHostV4Demo2(PCWSTR pszVersion, PCWSTR pszAssemblyPath, 

278:     PCWSTR pszClassName)

279: {

280:     HRESULT hr;

281:     ICLRMetaHost *pMetaHost = NULL;

282:     ICLRRuntimeInfo *pRuntimeInfo = NULL;

283:     // ICorRuntimeHost and ICLRRuntimeHost are the two CLR hosting interfaces

284:     // supported by CLR 4.0. Here we demo the ICLRRuntimeHost interface that 

285:     // was provided in .NET v2.0 to support CLR 2.0 new features. 

286:     // ICLRRuntimeHost does not support loading the .NET v1.x runtimes.

287:     ICLRRuntimeHost *pClrRuntimeHost = NULL;

288:     // The static method in the .NET class to invoke.

289:     PCWSTR pszStaticMethodName = L"GetStringLength";

290:     PCWSTR pszStringArg = L"HelloWorld";

291:     DWORD dwLengthRet;

292:     // 

293:     // Load and start the .NET runtime.

294:     // 

295:     wprintf(L"Load and start the .NET runtime %s \n", pszVersion);

296:     hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_PPV_ARGS(&pMetaHost));

297:     if (FAILED(hr))

298:     {

299:         wprintf(L"CLRCreateInstance failed w/hr 0x%08lx\n", hr);

300:         goto Cleanup;

301:     }

302:     // Get the ICLRRuntimeInfo corresponding to a particular CLR version. It 

303:     // supersedes CorBindToRuntimeEx with STARTUP_LOADER_SAFEMODE.

304:     hr = pMetaHost->GetRuntime(pszVersion, IID_PPV_ARGS(&pRuntimeInfo));

305:     if (FAILED(hr))

306:     {

307:         wprintf(L"ICLRMetaHost::GetRuntime failed w/hr 0x%08lx\n", hr);

308:         goto Cleanup;

309:     }

310:     // Check if the specified runtime can be loaded into the process. This 

311:     // method will take into account other runtimes that may already be 

312:     // loaded into the process and set pbLoadable to TRUE if this runtime can 

313:     // be loaded in an in-process side-by-side fashion. 

314:     BOOL fLoadable;

315:     hr = pRuntimeInfo->IsLoadable(&fLoadable);

316:     if (FAILED(hr))

317:     {

318:         wprintf(L"ICLRRuntimeInfo::IsLoadable failed w/hr 0x%08lx\n", hr);

319:         goto Cleanup;

320:     }

321:     if (!fLoadable)

322:     {

323:         wprintf(L".NET runtime %s cannot be loaded\n", pszVersion);

324:         goto Cleanup;

325:     }

326:     // Load the CLR into the current process and return a runtime interface 

327:     // pointer. ICorRuntimeHost and ICLRRuntimeHost are the two CLR hosting  

328:     // interfaces supported by CLR 4.0. Here we demo the ICLRRuntimeHost 

329:     // interface that was provided in .NET v2.0 to support CLR 2.0 new 

330:     // features. ICLRRuntimeHost does not support loading the .NET v1.x 

331:     // runtimes.

332:     hr = pRuntimeInfo->GetInterface(CLSID_CLRRuntimeHost, 

333:         IID_PPV_ARGS(&pClrRuntimeHost));

334:     if (FAILED(hr))

335:     {

336:         wprintf(L"ICLRRuntimeInfo::GetInterface failed w/hr 0x%08lx\n", hr);

337:         goto Cleanup;

338:     }

339:     // Start the CLR.

340:     hr = pClrRuntimeHost->Start();

341:     if (FAILED(hr))

342:     {

343:         wprintf(L"CLR failed to start w/hr 0x%08lx\n", hr);

344:         goto Cleanup;

345:     }

346:     // 

347:     // Load the NET assembly and call the static method GetStringLength of 

348:     // the type CSSimpleObject in the assembly.

349:     // 

350:     wprintf(L"Load the assembly %s\n", pszAssemblyPath);

351:     // The invoked method of ExecuteInDefaultAppDomain must have the 

352:     // following signature: static int pwzMethodName (String pwzArgument)

353:     // where pwzMethodName represents the name of the invoked method, and 

354:     // pwzArgument represents the string value passed as a parameter to that 

355:     // method. If the HRESULT return value of ExecuteInDefaultAppDomain is 

356:     // set to S_OK, pReturnValue is set to the integer value returned by the 

357:     // invoked method. Otherwise, pReturnValue is not set.

358:     hr = pClrRuntimeHost->ExecuteInDefaultAppDomain(pszAssemblyPath, 

359:         pszClassName, pszStaticMethodName, pszStringArg, &dwLengthRet);

360:     if (FAILED(hr))

361:     {

362:         wprintf(L"Failed to call GetStringLength w/hr 0x%08lx\n", hr);

363:         goto Cleanup;

364:     }

365:     // Print the call result of the static method.

366:     wprintf(L"Call %s.%s(\"%s\") => %d\n", pszClassName, pszStaticMethodName, 

367:         pszStringArg, dwLengthRet);

368: Cleanup:

369:     if (pMetaHost)

370:     {

371:         pMetaHost->Release();

372:         pMetaHost = NULL;

373:     }

374:     if (pRuntimeInfo)

375:     {

376:         pRuntimeInfo->Release();

377:         pRuntimeInfo = NULL;

378:     }

379:     if (pClrRuntimeHost)

380:     {

381:         // Please note that after a call to Stop, the CLR cannot be 

382:         // reinitialized into the same process. This step is usually not 

383:         // necessary. You can leave the .NET runtime loaded in your process.

384:         //wprintf(L"Stop the .NET runtime\n");

385:         //pClrRuntimeHost->Stop();

386:         pClrRuntimeHost->Release();

387:         pClrRuntimeHost = NULL;

388:     }

389:     return hr;

390: }

We mainly use two classes in proactive programming: System.Diagnostics.Debug and System.Diagnostics.Trace. You could open your reflector and find it in System.Diagnostics namespace. You’ll discover that almost all the methods of Trace and Debug class finally call TraceIntelnal’s methods which will retrieve listeners there. I introduce this, because you now understand why Debug and Trace could share some listeners.

Now, let’s get started by using the DefaultTraceListener provided by Microsoft .NET Framework. Please create a C# console application and add:

System.Diagnostics.Debug.Assert(1!=1, “1!=1”); // (C# version)
in Main function. Build the project and then press F5 to start debugging, you’ll receive a dialogbox like below:

At the mean time, the assert message was displayed in Output window in Visual Studio:
==========================================================

---- DEBUG ASSERTION FAILED ----

---- Assert Short Message ----

1!=1

---- Assert Long Message ----

at Program.Main(String[] args) C:\Projects\Debug\ConsoleApplication1\Program.cs(12)

at AppDomain._nExecuteAssembly(Assembly assembly, String[] args)

at AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)

at HostProc.RunUsersAssembly()

========================================================

Usually, developers wanted to disable the alert box and store the output information in a separate log file. To achieve that, you need to use TextWriterTraceListener and configure it in App.Config file like below:

  1: <system.diagnostics> 

  2:        <assert assertuienabled="false" logfilename="TraceLog.txt"/>

  3:        <listeners>

  4:         <remove name="Default"/>

  5:         <add initializeData="TraceLog.txt" name="MyListener" type="System.Diagnostics.TextWriterTraceListener, 
/>

  6:         System, 

  7:         Version=2.0.0.0, 

  8:         Culture=neutral,

  9:         PublicKeyToken=b77a5c561934e089"
 10: 

 11:       </listeners>

 12:     </system.diagnostics>

 13: 

Please note here:

  1: type="System.Diagnostics.TextWriterTraceListener, 

  2:       System, 

  3:        Version=2.0.0.0, 

  4:        Culture=neutral,     PublicKeyToken=b77a5c561934e089"/>

The order is: full type name, assembly name, assembly version number, culture and then the PublicKeyToken. Since this listener is already installed in GAC, you need to provide all those information for VS to locate the assembly. If you place your assembly in the Output path of your project, those information is not needed (just full type name and assembly name is OK). I’ll demonstrate that in the following custom TraceListener.

This time, if you press F5 to debug your application, you could find a TraceLog.txt file in your output folder. Most probablely, its content is:

Fail: 1!=1
As you can see, information here does not contain all the details but only a fail note. How to make it write all the details to this log file? One solution is to create a custom TextTraceListener and let it do works we want.

To implement a custom TraceListener, you could create a Class Library project and add a CustomTraceListener class which is inherited from TraceListener class. For example:

  1: 

  2:             Writer.WriteLine("Debug assert failed");

  3:             Writer.WriteLine("The message is:");

  4:             if (null != message)

  5:             {

  6:                 Writer.WriteLine(message);

  7:             }

  8:             Writer.WriteLine("The detail message is:");

  9:             if (null != detailMessage)

 10:             {

 11:                 Writer.WriteLine(detailMessage);

 12:             }

 13:  

 14:             // There's four levels of stack between here and the user's code.

 15:             StackTrace st = new StackTrace(3, true);

 16:             Writer.WriteLine(st.ToString());

 17:         }

 18:         #endregion

 19:     }

 20: }

Build the project and copy the dll file to the output of your test application. Make your App.Config have the following section:

  1:  <system.diagnostics>

  2:     <trace autoflush="true" indentsize="0">

  3:       <listeners>

  4:         <add name="CustomTraceListener" initializeData="TraceLog.log" 

  5:              type="CustomTraceListenerSample.CustomTraceListener, CustomTraceListenerSample"/>

  6:       </listeners>

  7:     </trace>

  8:   </system.diagnostics>

All the information that Debug and Trace detected will be written to TraceLog.log file. Well, happy proactive programming!​

Vivian Chen Focus in Visual Studio Setup  ,  5 Star Contributor at forum

  • Video: Sara Ford's 101 Visual Studio Tips in 55 minutes! https://bit.ly/aNNeOa #VS #IDE #Tip #SaraFord ^YC

  • Why .NET 4.0 are not supported on Windows Server 2008 R2 (Server Core)? https://bit.ly/9atpA9 #NET4 #WindowsServer2008 #Server Core #Support