ITypeDescriptorContext 인터페이스

참조

정의

네임스페이스:: System.ComponentModel

어셈블리:: System.ComponentModel.TypeConverter.dll

어셈블리:: System.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

컨테이너 및 속성 설명자와 같은 구성 요소에 대한 컨텍스트 정보를 제공합니다.

public interface class ITypeDescriptorContext : IServiceProvider

public interface ITypeDescriptorContext : IServiceProvider

[System.Runtime.InteropServices.ComVisible(true)]
public interface ITypeDescriptorContext : IServiceProvider

type ITypeDescriptorContext = interface
    interface IServiceProvider

[<System.Runtime.InteropServices.ComVisible(true)>]
type ITypeDescriptorContext = interface
    interface IServiceProvider

Public Interface ITypeDescriptorContext
Implements IServiceProvider

파생: System.Windows.Markup.IValueSerializerContext

특성: ComVisibleAttribute

구현: IServiceProvider

예제

다음 코드 예제에서는 인터페이스를 사용하여 형식 변환을 ITypeDescriptorContext 지원하는 방법을 보여 줍니다.

#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.
    */
ref class TriangleConverter;

[TypeConverter(TriangleConverter::typeid)]
public ref class Triangle
{
private:

   // Triangle members
   Point P1;
   Point P2;
   Point P3;

public:

   property Point Point1 
   {
      Point get()
      {
         return P1;
      }

      void set( Point value )
      {
         P1 = value;
      }
   }

   property Point Point2 
   {
      Point get()
      {
         return P2;
      }

      void set( Point value )
      {
         P2 = value;
      }
   }

   property Point Point3 
   {
      Point get()
      {
         return P3;
      }

      void set( 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. */
   [System::Security::Permissions::PermissionSet(System::Security::
      Permissions::SecurityAction::Demand, Name = "FullTrust")]
   ref class TriangleConverter: public TypeConverter
   {
   public:

      /* 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. */
      virtual bool CanConvertTo( ITypeDescriptorContext^ context, Type^ destinationType ) override
      {
         if ( destinationType == InstanceDescriptor::typeid )
         {
            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. */
      virtual Object^ ConvertTo( ITypeDescriptorContext^ context, CultureInfo^ culture, Object^ value, Type^ destinationType ) override
      {
         if ( destinationType == InstanceDescriptor::typeid )
         {
            array<Type^>^type1 = {Point::typeid,Point::typeid,Point::typeid};
            ConstructorInfo^ ci = Triangle::typeid->GetConstructor( type1 );
            Triangle^ t = safe_cast<Triangle^>(value);
            array<Object^>^obj1 = {t->Point1,t->Point2,t->Point3};
            return gcnew InstanceDescriptor( ci,safe_cast<ICollection^>(obj1) );
         }

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

public ref class TestComponent: public System::ComponentModel::Component
{
private:
   Triangle^ myTriangle;

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

   property Triangle^ MyTriangle 
   {
      Triangle^ get()
      {
         return myTriangle;
      }

      void set( Triangle^ value )
      {
         myTriangle = value;
      }
   }
};

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;
            }
        }
    }
}

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

      ' 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

설명

인터페이스는 ITypeDescriptorContext 구성 요소에 대한 컨텍스트 정보를 제공합니다. ITypeDescriptorContext 는 일반적으로 디자인 타임 컨테이너에 대한 정보를 제공하기 위해 디자인 타임에 사용됩니다. 이 인터페이스는 일반적으로 형식 변환에 사용됩니다. 자세한 내용은 TypeConverter를 참조하십시오.

참고

형식 변환기를 디자인할 때 이 인터페이스의 존재에 의존하지 마세요. 특정 인터페이스, 속성 또는 서비스가 필요하지만 사용할 수 없는 경우 형식 변환기는 예외를 throw하는 대신 를 반환 null 해야 합니다. 이 인터페이스의 속성은 언제든지 반환 null 할 수 있으며 이를 계획해야 합니다.

속성

Container	이 TypeDescriptor 요청을 나타내는 컨테이너를 가져옵니다.
Instance	이 형식 설명자 요청과 연결된 개체를 가져옵니다.
PropertyDescriptor	지정된 컨텍스트 항목과 연결된 PropertyDescriptor를 가져옵니다.

메서드

GetService(Type)	지정된 형식의 서비스 개체를 가져옵니다. (다음에서 상속됨 IServiceProvider)
OnComponentChanged()	ComponentChanged 이벤트를 발생시킵니다.
OnComponentChanging()	ComponentChanging 이벤트를 발생시킵니다.

확장 메서드

GetKeyedService<T>(IServiceProvider, Object)	에서 형식 `T` 의 서비스를 가져옵니다 IServiceProvider.
GetKeyedServices(IServiceProvider, Type, Object)	에서 형식 `serviceType` 의 서비스 열거형을 IServiceProvider가져옵니다.
GetKeyedServices<T>(IServiceProvider, Object)	에서 형식 `T` 의 서비스 열거형을 IServiceProvider가져옵니다.
GetRequiredKeyedService(IServiceProvider, Type, Object)	에서 형식 `serviceType` 의 서비스를 가져옵니다 IServiceProvider.
GetRequiredKeyedService<T>(IServiceProvider, Object)	에서 형식 `T` 의 서비스를 가져옵니다 IServiceProvider.
CreateAsyncScope(IServiceProvider)	범위 서비스를 확인하는 데 사용할 수 있는 새 AsyncServiceScope를 만듭니다.
CreateScope(IServiceProvider)	범위 서비스를 확인하는 데 사용할 수 있는 새 IServiceScope를 만듭니다.
GetRequiredService(IServiceProvider, Type)	IServiceProvider에서 `serviceType` 형식의 서비스를 가져옵니다.
GetRequiredService<T>(IServiceProvider)	IServiceProvider에서 `T` 형식의 서비스를 가져옵니다.
GetService<T>(IServiceProvider)	IServiceProvider에서 `T` 형식의 서비스를 가져옵니다.
GetServices(IServiceProvider, Type)	IServiceProvider에서 `serviceType` 형식의 서비스 열거형을 가져옵니다.
GetServices<T>(IServiceProvider)	IServiceProvider에서 `T` 형식의 서비스 열거형을 가져옵니다.
GetFakeLogCollector(IServiceProvider)	가짜 로거로 전송된 로그 레코드를 수집하는 개체를 가져옵니다.
GetFakeRedactionCollector(IServiceProvider)	종속성 주입 컨테이너에서 가짜 재배포기 수집기 instance 가져옵니다.

적용 대상

다음을 통해 공유

ITypeDescriptorContext 인터페이스

정의

예제

설명

속성

메서드

확장 메서드

적용 대상

추가 정보

추가 리소스