InstanceDescriptor Class

Provides information necessary to create an instance of an object. This class cannot be inherited.

For a list of all members of this type, see InstanceDescriptor Members.

System.Object
System.ComponentModel.Design.Serialization.InstanceDescriptor

[Visual Basic]
NotInheritable Public Class InstanceDescriptor
[C#]
public sealed class InstanceDescriptor
[C++]
public __gc __sealed class InstanceDescriptor
[JScript]
public class InstanceDescriptor

Thread Safety

Any public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Any instance members are not guaranteed to be thread safe.

Remarks

InstanceDescriptor can store information that describes an instance of an object. This information can be used to create an instance of the object.

Some custom serializers use InstanceDescriptor to represent serializable objects. Several methods of a TypeDescriptor use InstanceDescriptor to represent or instantiate objects.

An InstanceDescriptor provides the following members:

A MemberInfo property that describes this object.
An Arguments property that consists of the constructor arguments that can be used to instantiate this object.
A Boolean IsComplete property that indicates whether the object is completely represented by the current information.
An Invoke method that can be used to create an instance of the represented object.

Example

[Visual Basic, C#, C++] The following example illustrates how to use a type converter that participates in code generation through the use of instance descriptors.

[Visual Basic] 
Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design.Serialization
Imports System.Drawing
Imports System.Globalization
Imports System.Reflection
Namespace Microsoft.Samples.InstanceDescriptorSample

   '  This sample shows how to support code generation for a custom type 
   '  of object using a type converter and InstanceDescriptor objects.
   '
   '  To use this code, copy it to a file and add the file to a project.  
   '  Then add a component to the project and declare a Triangle field and 
   '  a public property with accessors for the Triangle field on the component.
   '
   '  The Triangle property will be persisted using code generation.

   <TypeConverter(GetType(Triangle.TriangleConverter))> _
   Public Class Triangle
      ' Triangle members.
      Private P1 As Point
      Private P2 As Point
      Private P3 As Point

      Public Property Point1() As Point
         Get
            Return P1
         End Get
         Set(ByVal Value As Point)
            P1 = Value
         End Set
      End Property

      Public Property Point2() As Point
         Get
            Return P2
         End Get
         Set(ByVal Value As Point)
            P2 = Value
         End Set
      End Property

      Public Property Point3() As Point
         Get
            Return P3
         End Get
         Set(ByVal Value As Point)
            P3 = Value
         End Set
      End Property

      Public Sub New(ByVal point1 As Point, ByVal point2 As Point, ByVal point3 As Point)
         P1 = point1
         P2 = point2
         P3 = point3
      End Sub 'New

      ' A TypeConverter for the Triangle object.  Note that you can make it internal,
      '  private, or any scope you want and the designers will still be able to use
      '  it through the TypeDescriptor object.  This type converter provides the
      '  capability to convert to an InstanceDescriptor.  This object can be used by 
      '  the .NET Framework to generate source code that creates an instance of a 
      '  Triangle object.

      Friend Class TriangleConverter
         Inherits TypeConverter

         ' This method overrides CanConvertTo from TypeConverter.  This is called when someone
         '  wants to convert an instance of Triangle to another type.  Here,
         '  only coversition to an InstanceDescriptor is supported.
         Public Overloads Overrides Function CanConvertTo(ByVal context As ITypeDescriptorContext, ByVal destinationType As Type) As Boolean
            If destinationType Is GetType(InstanceDescriptor) Then
               Return True
            End If

            ' Always call the base to see if it can perform the conversion.
            Return MyBase.CanConvertTo(context, destinationType)
         End Function

         ' This code performs the actual conversion from a Triangle to an InstanceDescriptor.
         Public Overloads Overrides Function ConvertTo(ByVal context As ITypeDescriptorContext, ByVal culture As CultureInfo, ByVal value As Object, ByVal destinationType As Type) As Object
            If destinationType Is GetType(InstanceDescriptor) Then
               Dim ci As ConstructorInfo = GetType(Triangle).GetConstructor(New Type() {GetType(Point), GetType(Point), GetType(Point)})
               Dim t As Triangle = CType(value, Triangle)
               Return New InstanceDescriptor(ci, New Object() {t.Point1, t.Point2, t.Point3})
            End If

            ' Always call base, even if you can't convert.
            Return MyBase.ConvertTo(context, culture, value, destinationType)
         End Function 
      End Class 
   End Class 

   Public Class TestComponent
      Inherits System.ComponentModel.Component
      Private myTriangleProp As Triangle

      Public Sub New()
         myTriangleProp = New Triangle(New Point(5, 5), _
                                    New Point(10, 10), New Point(1, 8))
      End Sub

      Public Property MyTriangle() As Triangle
         Get
            Return myTriangleProp
         End Get
         Set(ByVal Value As Triangle)
            myTriangleProp = Value
         End Set
      End Property

   End Class

End Namespace

[C#] 
namespace Microsoft.Samples.InstanceDescriptorSample
{
    using System;
    using System.ComponentModel;
    using System.ComponentModel.Design.Serialization;
    using System.Drawing;
    using System.Globalization;
    using System.Reflection;

    //  This sample shows how to support code generation for a custom type 
    //  of object using a type converter and InstanceDescriptor objects.

    //  To use this code, copy it to a file and add the file to a project. 
    //  Then add a component to the project and declare a Triangle field and 
    //  a public property with accessors for the Triangle field on the component.

    //  The Triangle property will be persisted using code generation.

    [TypeConverter(typeof(Triangle.TriangleConverter))]
    public class Triangle
    {
        // Triangle members.
        Point P1;
        Point P2;
        Point P3;

        public Point Point1 {
            get {
                return P1;
            }
            set {
                P1 = value;
            }
        }
        public Point Point2 {
            get 
            {
                return P2;
            }
            set 
            {
                P2 = value;
            }
        }
        public Point Point3 {
            get 
            {
                return P3;
            }
            set 
            {
                P3 = value;
            }
        }

        public Triangle(Point point1,Point point2,Point point3) {
            P1 = point1;
            P2 = point2;
            P3 = point3;
        }

        // A TypeConverter for the Triangle object.  Note that you can make it internal,
        //  private, or any scope you want and the designers will still be able to use
        //  it through the TypeDescriptor object.  This type converter provides the
        //  capability to convert to an InstanceDescriptor.  This object can be used by 
    //  the .NET Framework to generate source code that creates an instance of a 
    //  Triangle object.
        internal class TriangleConverter : TypeConverter
        {
            // This method overrides CanConvertTo from TypeConverter. This is called when someone
            //  wants to convert an instance of Triangle to another type.  Here,
            //  only conversion to an InstanceDescriptor is supported.
            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
            {
                if (destinationType == typeof(InstanceDescriptor))
                {
                    return true;
                }

                // Always call the base to see if it can perform the conversion.
                return base.CanConvertTo(context, destinationType);
            }

            // This code performs the actual conversion from a Triangle to an InstanceDescriptor.
            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
            {
                if (destinationType == typeof(InstanceDescriptor))
                {
                    ConstructorInfo ci = typeof(Triangle).GetConstructor(new Type[]{typeof(Point),
                                                    typeof(Point),typeof(Point)});
                    Triangle t = (Triangle) value;
                    return new InstanceDescriptor(ci,new object[]{t.Point1,t.Point2,t.Point3});
                }

                // Always call base, even if you can't convert.
                return base.ConvertTo(context, culture, value, destinationType);
            }
        }
    }

    public class TestComponent : System.ComponentModel.Component 
    {
        Triangle myTriangle;

        public TestComponent() {
            myTriangle = new Triangle(
                new Point(5,5),
                new Point(10,10),
                new Point(1,8)
                );
        }

        public Triangle MyTriangle {
            get {
                return myTriangle;
            }
            set {
                myTriangle = value;
            }
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <system.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design::Serialization;
using namespace System::Drawing;
using namespace System::Globalization;
using namespace System::Collections;
using namespace System::Reflection;

    /*   This sample shows how to support code generation for a custom type of object 
         using a type converter and InstanceDescriptor objects.

         To use this code, copy it to a file and add the file to a project. Then add
         a component to the project and declare a Triangle field and a public property 
         with accessors for the Triangle field on the component.

         The Triangle property will be persisted using code generation.
    */

__gc class TriangleConverter;

[TypeConverter(__typeof(Triangle::TriangleConverter))]
public __gc class Triangle
{
   // Triangle members
   Point P1;
   Point P2;
   Point P3;

public:
   __property Point get_Point1()
   {
      return P1;
   }
   __property void set_Point1(Point value)
   {
      P1 = value;
   }
   __property Point get_Point2()
   {
      return P2;
   }
   __property void set_Point2(Point value)
   {
      P2 = value;
   }
   __property Point get_Point3()
   {
      return P3;
   }
   __property void set_Point3(Point value)
   {
      P3 = value;
   }
   Triangle(Point point1, Point point2, Point point3) {
      P1 = point1;
      P2 = point2;
      P3 = point3;
   }

   /* A TypeConverter for the Triangle object.  Note that you can make it internal,
   private, or any scope you want and the designers will still be able to use
   it through the TypeDescriptor object.  This type converter provides the
   capability to convert to an InstanceDescriptor.  This object can be used by 
   the .NET Framework to generate source code that creates an instance of a 
   Triangle object. */
   __gc class TriangleConverter : public TypeConverter 
   {
      /* This method overrides CanConvertTo from TypeConverter. This is called when someone
      wants to convert an instance of Triangle to another type.  Here,
      only conversion to an InstanceDescriptor is supported. */
   public:
      bool CanConvertTo(ITypeDescriptorContext* context, Type* destinationType) 
      {
         if (destinationType == __typeof(InstanceDescriptor)) {
            return true;
         }

         // Always call the base to see if it can perform the conversion.
         return TypeConverter::CanConvertTo(context, destinationType);
      }

      /* This code performs the actual conversion from a Triangle to an InstanceDescriptor. */
      Object* ConvertTo(ITypeDescriptorContext* context, CultureInfo* culture, Object* value, Type* destinationType)
      {
         if (destinationType == __typeof(InstanceDescriptor)) {
            Type* type1[] = {__typeof(Point), __typeof(Point), __typeof(Point)};
            ConstructorInfo* ci = __typeof(Triangle)->GetConstructor(type1);
            Triangle* t = __try_cast<Triangle*>(value);
            Object* obj1[] = {__box(t->Point1), __box(t->Point2), __box(t->Point3)};
            return new InstanceDescriptor(ci, __try_cast<ICollection*>(obj1));
         }

         // Always call base, even if you can't convert.
         return TypeConverter::ConvertTo(context, culture, value, destinationType);
      }
   };
};
public __gc class TestComponent : public System::ComponentModel::Component
{
   Triangle* myTriangle;

public:
   TestComponent()
   {
      myTriangle = new Triangle( Point(5, 5), Point(10, 10), Point(1, 8));
   }

   __property Triangle* get_MyTriangle()
   {
      return myTriangle;
   }
   __property void set_MyTriangle(Triangle* value)
   {
      myTriangle = value;
   }
};

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

Requirements

Namespace: System.ComponentModel.Design.Serialization

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

Assembly: System (in System.dll)

InstanceDescriptor Class

Thread Safety

Remarks

Example

Requirements

See Also