INameCreationService Interfaccia

Riferimento

Definizione

Spazio dei nomi:: System.ComponentModel.Design.Serialization

Assembly:: System.ComponentModel.TypeConverter.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce un servizio in grado di generare nomi univoci per gli oggetti.

public interface class INameCreationService

public interface INameCreationService

type INameCreationService = interface

Public Interface INameCreationService

Derivato: System.ComponentModel.Design.Serialization.CodeDomDesignerLoader

Esempio

Il codice di esempio seguente fornisce un'implementazione di esempio INameCreationService . Il servizio può creare un nome univoco basato su un tipo che non corrisponde ad alcun nome nel contenitore specificato. Può anche convalidare una stringa di nome specificata.

#using <System.dll>

using namespace System;
using namespace System::ComponentModel::Design;
using namespace System::ComponentModel::Design::Serialization;
using namespace System::Globalization;

namespace NameCreationServiceExample
{
   public ref class NameCreationService: public System::ComponentModel::Design::Serialization::INameCreationService
   {
   public:
      NameCreationService(){}

      // Creates an identifier for a particular data type that does not conflict 
      // with the identifiers of any components in the specified collection.
      virtual String^ CreateName( System::ComponentModel::IContainer^ container, System::Type^ dataType )
      {
         // Create a basic type name string.
         String^ baseName = dataType->Name;
         int uniqueID = 1;
         bool unique = false;

         // Continue to increment uniqueID numeral until a 
         // unique ID is located.
         while (  !unique )
         {
            unique = true;

            // Check each component in the container for a matching 
            // base type name and unique ID.
            for ( int i = 0; i < container->Components->Count; i++ )
            {
               // Check component name for match with unique ID string.
               if ( container->Components[ i ]->Site->Name->StartsWith( String::Concat( baseName, uniqueID ) ) )
               {
                  // If a match is encountered, set flag to recycle 
                  // collection, increment ID numeral, and restart.
                  unique = false;
                  uniqueID++;
                  break;
               }
            }
         }

         return String::Concat( baseName, uniqueID );
      }

      // Returns whether the specified name contains 
      // all valid character types.
      virtual bool IsValidName( String^ name )
      {
         for ( int i = 0; i < name->Length; i++ )
         {
            Char ch = name[ i ];
            UnicodeCategory uc = Char::GetUnicodeCategory( ch );
            switch ( uc )
            {
               case UnicodeCategory::UppercaseLetter:
               case UnicodeCategory::LowercaseLetter:
               case UnicodeCategory::TitlecaseLetter:
               case UnicodeCategory::DecimalDigitNumber:
                  break;

               default:
                  return false;
            }
         }
         return true;
      }

      // Throws an exception if the specified name does not contain 
      // all valid character types.
      virtual void ValidateName( String^ name )
      {
         for ( int i = 0; i < name->Length; i++ )
         {
            Char ch = name[ i ];
            UnicodeCategory uc = Char::GetUnicodeCategory( ch );
            switch ( uc )
            {
               case UnicodeCategory::UppercaseLetter:
               case UnicodeCategory::LowercaseLetter:
               case UnicodeCategory::TitlecaseLetter:
               case UnicodeCategory::DecimalDigitNumber:
                  break;

               default:
                  throw gcnew Exception( String::Format( "The name '{0}' is not a valid identifier.", name ) );
            }
         }
      }
   };
}

using System;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Globalization;

namespace NameCreationServiceExample
{
    public class NameCreationService : System.ComponentModel.Design.Serialization.INameCreationService
    {
        public NameCreationService()
        {
        }

        // Creates an identifier for a particular data type that does not conflict 
        // with the identifiers of any components in the specified collection.
        public string CreateName(System.ComponentModel.IContainer container, System.Type dataType)
        {
            // Create a basic type name string.
            string baseName = dataType.Name;
            int uniqueID = 1;

            bool unique = false;            
            // Continue to increment uniqueID numeral until a 
            // unique ID is located.
            while( !unique )
            {
                unique = true;
                // Check each component in the container for a matching 
                // base type name and unique ID.
                for(int i=0; i<container.Components.Count; i++)
                {
                    // Check component name for match with unique ID string.
                    if( container.Components[i].Site.Name.StartsWith(baseName+uniqueID.ToString()) )
                    {
                        // If a match is encountered, set flag to recycle 
                        // collection, increment ID numeral, and restart.
                        unique = false;
                        uniqueID++;
                        break;
                    }
                }
            }
            
            return baseName+uniqueID.ToString();
        }

        // Returns whether the specified name contains 
        // all valid character types.
        public bool IsValidName(string name)
        {            
            for(int i = 0; i < name.Length; i++)
            {
                char ch = name[i];
                UnicodeCategory uc = Char.GetUnicodeCategory(ch);
                switch (uc) 
                {
                    case UnicodeCategory.UppercaseLetter:       
                    case UnicodeCategory.LowercaseLetter:     
                    case UnicodeCategory.TitlecaseLetter:                                                  
                    case UnicodeCategory.DecimalDigitNumber:                         
                        break;
                    default:
                        return false;                
                }
            }
            return true;        
         }

        // Throws an exception if the specified name does not contain 
        // all valid character types.
        public void ValidateName(string name)
        {
            for(int i = 0; i < name.Length; i++)
            {
                char ch = name[i];
                UnicodeCategory uc = Char.GetUnicodeCategory(ch);
                switch (uc) 
                {
                    case UnicodeCategory.UppercaseLetter:       
                    case UnicodeCategory.LowercaseLetter:     
                    case UnicodeCategory.TitlecaseLetter:                                                  
                    case UnicodeCategory.DecimalDigitNumber:                         
                        break;
                    default:
                        throw new Exception("The name '"+name+"' is not a valid identifier.");                
                }
            }
        }
     }
}

Imports System.ComponentModel.Design
Imports System.ComponentModel.Design.Serialization
Imports System.Globalization

Public Class NameCreationService
    Implements System.ComponentModel.Design.Serialization.INameCreationService

    Public Sub New()
    End Sub

    ' Creates an identifier for a particular data type that does not conflict 
    ' with the identifiers of any components in the specified collection
    Public Function CreateName(ByVal container As System.ComponentModel.IContainer, ByVal dataType As System.Type) As String Implements INameCreationService.CreateName
        ' Create a basic type name string
        Dim baseName As String = dataType.Name
        Dim uniqueID As Integer = 1

        Dim unique As Boolean = False
        ' Continue to increment uniqueID numeral until a unique ID is located.
        While Not unique
            unique = True
            ' Check each component in the container for a matching 
            ' base type name and unique ID.
            Dim i As Integer
            For i = 0 To container.Components.Count - 1
                ' Check component name for match with unique ID string.
                If container.Components(i).Site.Name.StartsWith((baseName + uniqueID.ToString())) Then
                    ' If a match is encountered, set flag to recycle 
                    ' collection, increment ID numeral, and restart.
                    unique = False
                    uniqueID += 1
                    Exit For
                End If
            Next i
        End While

        Return baseName + uniqueID.ToString()
    End Function

    ' Returns whether the specified name contains 
    ' all valid character types.
    Public Function IsValidName(ByVal name As String) As Boolean Implements INameCreationService.IsValidName
        Dim i As Integer
        For i = 0 To name.Length - 1
            Dim ch As Char = name.Chars(i)
            Dim uc As UnicodeCategory = [Char].GetUnicodeCategory(ch)
            Select Case uc
                Case UnicodeCategory.UppercaseLetter, UnicodeCategory.LowercaseLetter, UnicodeCategory.TitlecaseLetter, UnicodeCategory.DecimalDigitNumber
                Case Else
                    Return False
            End Select
        Next i
        Return True
    End Function

    ' Throws an exception if the specified name does not contain 
    ' all valid character types.
    Public Sub ValidateName(ByVal name As String) Implements INameCreationService.ValidateName
        Dim i As Integer
        For i = 0 To name.Length - 1
            Dim ch As Char = name.Chars(i)
            Dim uc As UnicodeCategory = [Char].GetUnicodeCategory(ch)
            Select Case uc
                Case UnicodeCategory.UppercaseLetter, UnicodeCategory.LowercaseLetter, UnicodeCategory.TitlecaseLetter, UnicodeCategory.DecimalDigitNumber
                Case Else
                    Throw New Exception("The name '" + name + "' is not a valid identifier.")
            End Select
        Next i
    End Sub

End Class

Commenti

Un DesignerLoader oggetto può implementare questo servizio per consentire a una finestra di progettazione di creare nuovi nomi univoci per gli oggetti. Se questo servizio non è disponibile, la finestra di progettazione usa un'implementazione predefinita.

Metodi

CreateName(IContainer, Type)	Crea un nuovo nome univoco per tutti i componenti nel contenitore specificato.
IsValidName(String)	Ottiene un valore che indica se il nome specificato è valido.
ValidateName(String)	Ottiene un valore che indica se il nome specificato è valido.

Si applica a

Condividi tramite