M2558 – Programming with Managed Extensions for Microsoft Visual C++ .NET
Enquire/Book this course
Trained over 60000 delegates
Course delivered by industry expert instructors
Highly competitive pricing
Course Description
The goal of this course is to teach existing C++ developers how to write applications for the Microsoft .NET Framework by using Managed Extensions for C++. The course teaches the language differences between standard C++ and Managed Extensions for C++, and focuses on issues such as efficiency and optimization. The course also discusses interoperability with unmanaged code, and shows how to use COM effectively in managed code.
Target Student: This course is intended for corporate developers, solution providers, IT Web developers, and IT database developers who are responsible for building knowledge management solutions that provide data analysis, reporting, presentation, and workflow.
Prerequisites: Before attending this course, students must have:
- Programming experience with C++, using object-oriented programming techniques.
- Familiarity with C++ template libraries.
Delivery Method: Instructor led, group-paced, classroom-delivery learning model with structured hands-on activities.
Performance-Based Objectives
After completing this module, students will be able to:
- Create Managed C++ applications that execute in the .NET Framework.
- Define __gc (garbage collected) classes in C++.
- Use __gc pointers and references.
- Define and use value types.
- Use inheritance with __gc classes.
- Use __gc arrays, .NET Framework collections, and reflection.
- Use properties, named operator functions, and exceptions in managed code.
- Migrate unmanaged C++ code to Managed C++.
- Use COM interoperability with managed code.
Course Content
Module 1: Managed C++ Applications and the .NET Framework
Lessons
- Using C++ in the .NET Framework
- The .NET Framework and Managed Execution Environment
- Programming with Managed Extensions for C++
- Using .NET Framework Developer Tools
After completing this module, you will be able to create Managed C++ projects that use the .NET Framework. This includes:
- Creating native and Managed C++ applications.
- Writing code to use managed types in a C++ application.
- Creating, building, and testing C++ projects for the .NET Framework.
Module 2: Defining __gc Classes
Lessons
- Defining Classes in Managed C++
- Defining Members in a __gc Class
- Controlling Class Layout
After completing this module, you will be able to define and use __gc classes. This includes:
- Defining __gc classes, and creating and destroying objects of these classes.
- Defining data members, member functions, constructors, and destructors in a __gc class.
- Controlling the layout of classes and unions.
Module 3: __gc Pointers and References
Lessons
- Pointers and References to __gc and __nogc Objects
- Pinning and Unpinning Pointers
- Delegates and Events
After completing this module, you will be able to define and use pointers to __gc and __nogc objects. This includes:
- Defining and using pointers and references to __gc and __nogc objects.
- inning a pointer to a fixed location, to prevent an object from being relocated by the runtime system.
- Defining delegates to represent member functions in a class
- Using delegates to specify callback functions for events.
Module 4: Value Types
Lessons
- Creating and Using Value Types
- Boxing and Unboxing Value Types
- Value Enums
After completing this module, you will be able to create and use value types. This includes:
- Defining and using a value type.
- erforming boxing and unboxing operations on a value type, so that it can be used where a managed object is required.
- Defining and using value enums
Module 5: Managed Inheritance
Lessons
- Defining Base Classes and Derived Classes
- Interfaces
- Using Inheritance with Other .NET Framework Languages
After completing this module, you will be able to define __gc base classes, derived classes, and interfaces in C++. This includes:
- Defining base classes and derived classes that use the Managed Extensions for C++.
- Defining and implementing interfaces.
- Defining Managed C++ base classes and derived classes that integrate with classes written in Microsoft Visual Basic .NET and Microsoft Visual C#„.
Module 6: Arrays, Collections, and Reflection
Lessons
- Defining and Using _gc Arrays
- Using .NET Framework Collection Classes
- Using Reflection
After completing this module, you will be able to create arrays and collections of objects, and use reflection to obtain run time information about objects. This includes:
- Creating, initializing, using, and destroying __gc arrays.
- Using the .NET Framework collection class library to organize objects.
- Using reflection to identify the type, data members, and member functions of an object at run time.
Module 7: Properties, Managed Operators, and Managed Exceptions
Lessons
- Defining and Using Properties
- Defining and Using Managed Operator Functions
- Exception Handling
After completing this module, you will be able to define and use properties, managed operator functions, and exceptions. This includes:
- Defining properties in a __gc class.
- Defining named operator functions in a __gc class.
- Using exception handling techniques to deal with error conditions in a Managed C++ application.
Module 8: Mixing Managed and Unmanaged Code
Lessons
- Directly Invoking Native APIs in Managed Code
- Wrapping a __nogc Class in a __gc Class
After completing this module, you will be able to call unmanaged code from managed code, and wrap an unmanaged class in a managed class. This includes:
- Invoking native APIs directly in managed code, using a direct function call or using P/Invoke.
- Defining a __gc C++ class to wrap an unmanaged C++ class, to expose the unmanaged class to the .NET Framework.
Module 9: COM Interoperability
Lessons
- Importing a COM Type Library into an Interop Assembly
- Using Imported COM Objects
- Exporting an Assembly into a COM Type Library
After completing this module, you will be able to use COM objects in managed code, and export managed classes to COM. This includes:
- Converting the type definitions in a COM type library into a .NET Framework interop assembly.
- Creating and using instances of imported COM objects within a Managed C++ application.
- Using the Type Library Exporter tool to convert managed types into a COM type library.
