IIdentifierCreationService IIdentifierCreationService IIdentifierCreationService IIdentifierCreationService Interface

定義

警告

此 API 現已淘汰。

提供一個在指定活動範圍內建立唯一名稱識別項的機制。Provides a mechanism to create uniquely named identifiers throughout a specified range of activities.

public interface class IIdentifierCreationService
[System.Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
public interface IIdentifierCreationService
type IIdentifierCreationService = interface
Public Interface IIdentifierCreationService
屬性

範例

下列範例將示範 IIdentifierCreationService 的實作。The following example shows an implementation of the IIdentifierCreationService. 這個服務可確保目前工作流程中所使用的每一個識別項都是唯一的。This service ensures that each of the identifiers used within the current workflow is unique.

internal sealed class IdentifierCreationService : IIdentifierCreationService
{
    private IServiceProvider serviceProvider = null;

    internal IdentifierCreationService(IServiceProvider serviceProvider)
    {
        this.serviceProvider = serviceProvider;
    }

    void IIdentifierCreationService.ValidateIdentifier(Activity activity, string identifier)
    {
        if (identifier == null)
            throw new ArgumentNullException("identifier");
        if (activity == null)
            throw new ArgumentNullException("activity");

        if (activity.Name.ToLower().Equals(identifier.ToLower()))
            return;

        ArrayList identifiers = new ArrayList();
        Activity rootActivity = GetRootActivity(activity);
        identifiers.AddRange(GetIdentifiersInCompositeActivity(rootActivity as CompositeActivity));
        identifiers.Sort();
        if (identifiers.BinarySearch(identifier.ToLower(), StringComparer.OrdinalIgnoreCase) >= 0)
            throw new ArgumentException(string.Format("Duplicate Component Identifier {0}", identifier));
    }

    void IIdentifierCreationService.EnsureUniqueIdentifiers(CompositeActivity parentActivity, ICollection childActivities)
    {
        if (parentActivity == null)
            throw new ArgumentNullException("parentActivity");
        if (childActivities == null)
            throw new ArgumentNullException("childActivities");

        List<Activity> allActivities = new List<Activity>();

        Queue activities = new Queue(childActivities);
        while (activities.Count > 0)
        {
            Activity activity = (Activity)activities.Dequeue();
            if (activity is CompositeActivity)
            {
                foreach (Activity child in ((CompositeActivity)activity).Activities)
                    activities.Enqueue(child);
            }

            //If we are moving activities, we need not regenerate their identifiers
            if (((IComponent)activity).Site != null)
                continue;

            allActivities.Add(activity);
        }

        // get the root activity
        CompositeActivity rootActivity = GetRootActivity(parentActivity) as CompositeActivity;
        ArrayList identifiers = new ArrayList(); // all the identifiers in the workflow
        identifiers.AddRange(GetIdentifiersInCompositeActivity(rootActivity));

        foreach (Activity activity in allActivities)
        {
            string finalIdentifier = activity.Name;

            // now loop until we find a identifier that hasn't been used.
            string baseIdentifier = GetBaseIdentifier(activity);
            int index = 0;

            identifiers.Sort();
            while (finalIdentifier == null || finalIdentifier.Length == 0 || identifiers.BinarySearch(finalIdentifier.ToLower(), StringComparer.OrdinalIgnoreCase) >= 0)
            {
                finalIdentifier = string.Format("{0}{1}", baseIdentifier, ++index);
            }

            // add new identifier to collection 
            identifiers.Add(finalIdentifier);
            activity.Name = finalIdentifier;
        }
    }

    private static IList GetIdentifiersInCompositeActivity(CompositeActivity compositeActivity)
    {
        ArrayList identifiers = new ArrayList();
        if (compositeActivity != null)
        {
            identifiers.Add(compositeActivity.Name);
            IList<Activity> allChildren = GetAllNestedActivities(compositeActivity);
            foreach (Activity activity in allChildren)
                identifiers.Add(activity.Name);
        }
        return ArrayList.ReadOnly(identifiers);
    }

    private static string GetBaseIdentifier(Activity activity)
    {
        string baseIdentifier = activity.GetType().Name;
        StringBuilder b = new StringBuilder(baseIdentifier.Length);
        for (int i = 0; i < baseIdentifier.Length; i++)
        {
            if (Char.IsUpper(baseIdentifier[i]) && (i == 0 || i == baseIdentifier.Length - 1 || Char.IsUpper(baseIdentifier[i + 1])))
            {
                b.Append(Char.ToLower(baseIdentifier[i]));
            }
            else
            {
                b.Append(baseIdentifier.Substring(i));
                break;
            }
        }
        return b.ToString();
    }

    private static Activity GetRootActivity(Activity activity)
    {
        if (activity == null)
            throw new ArgumentException("activity");

        while (activity.Parent != null)
            activity = activity.Parent;

        return activity;
    }

    private static Activity[] GetAllNestedActivities(CompositeActivity compositeActivity)
    {
        if (compositeActivity == null)
            throw new ArgumentNullException("compositeActivity");

        ArrayList nestedActivities = new ArrayList();
        Queue compositeActivities = new Queue();
        compositeActivities.Enqueue(compositeActivity);
        while (compositeActivities.Count > 0)
        {
            CompositeActivity compositeActivity2 = (CompositeActivity)compositeActivities.Dequeue();

            foreach (Activity activity in compositeActivity2.Activities)
            {
                nestedActivities.Add(activity);
                if (activity is CompositeActivity)
                    compositeActivities.Enqueue(activity);
            }

            foreach (Activity activity in compositeActivity2.EnabledActivities)
            {
                if (!nestedActivities.Contains(activity))
                {
                    nestedActivities.Add(activity);
                    if (activity is CompositeActivity)
                        compositeActivities.Enqueue(activity);
                }
            }
        }
        return (Activity[])nestedActivities.ToArray(typeof(Activity));
    }
}
Friend NotInheritable Class IdentifierCreationService
    Implements IIdentifierCreationService
    Private serviceProvider As IServiceProvider = Nothing

    Friend Sub New(ByVal serviceProvider As IServiceProvider)
        Me.serviceProvider = serviceProvider
    End Sub

    Sub ValidateIdentifier(ByVal activity As Activity, ByVal identifier As String) Implements IIdentifierCreationService.ValidateIdentifier
        If identifier Is Nothing Then
            Throw New ArgumentNullException("identifier")
        End If
        If activity Is Nothing Then
            Throw New ArgumentNullException("activity")
        End If
        If activity.Name.ToLower().Equals(identifier.ToLower()) Then
            Return
        End If
        Dim identifiers As New ArrayList()
        Dim rootActivity As Activity = GetRootActivity(activity)
        identifiers.AddRange(GetIdentifiersInCompositeActivity(CType(rootActivity, CompositeActivity)))
        identifiers.Sort()
        If identifiers.BinarySearch(identifier.ToLower(), StringComparer.OrdinalIgnoreCase) >= 0 Then
            Throw New ArgumentException(String.Format("Duplicate Component Identifier 0}", identifier))
        End If
    End Sub

    Sub EnsureUniqueIdentifiers(ByVal parentActivity As CompositeActivity, ByVal childActivities As ICollection) Implements IIdentifierCreationService.EnsureUniqueIdentifiers

        If parentActivity Is Nothing Then
            Throw New ArgumentNullException("parentActivity")
        End If
        If childActivities Is Nothing Then
            Throw New ArgumentNullException("childActivities")
        End If
        Dim allActivities As New List(Of Activity)()

        Dim activities As New Queue(childActivities)
        While activities.Count > 0

            Dim activity As Activity = CType(activities.Dequeue(), Activity)
            If TypeOf activity Is CompositeActivity Then
                For Each child As Activity In CType(activity, CompositeActivity).Activities
                    activities.Enqueue(child)
                Next
            End If

            'If we are moving activities, we need not regenerate their identifiers
            If CType(activity, IComponent).Site IsNot Nothing Then
                Continue While
            End If

            allActivities.Add(activity)
        End While

        ' get the root activity
        Dim rootActivity As CompositeActivity = CType(GetRootActivity(parentActivity), CompositeActivity)
        Dim identifiers As New ArrayList() ' all the identifiers in the workflow
        identifiers.AddRange(GetIdentifiersInCompositeActivity(rootActivity))

        For Each activity As Activity In allActivities

            Dim finalIdentifier As String = activity.Name

            ' now loop until we find a identifier that hasn't been used.
            Dim baseIdentifier As String = GetBaseIdentifier(activity)
            Dim index As Integer = 0

            identifiers.Sort()
            While finalIdentifier Is Nothing Or _
            finalIdentifier.Length = 0 Or _
            identifiers.BinarySearch(finalIdentifier.ToLower(), StringComparer.OrdinalIgnoreCase) >= 0
                finalIdentifier = String.Format("0}1}", baseIdentifier, ++index)
            End While

            ' add new identifier to collection 
            identifiers.Add(finalIdentifier)
            activity.Name = finalIdentifier
        Next
    End Sub

    Private Shared Function GetIdentifiersInCompositeActivity(ByVal CompositeActivity As CompositeActivity) As IList
        Dim identifiers As New ArrayList()
        If CompositeActivity IsNot Nothing Then
            identifiers.Add(CompositeActivity.Name)
            Dim allChildren As IList(Of Activity) = GetAllNestedActivities(CompositeActivity)
            For Each activity As Activity In allChildren
                identifiers.Add(activity.Name)
            Next
        End If

        Return ArrayList.ReadOnly(identifiers)
    End Function

    Private Shared Function GetBaseIdentifier(ByVal activity As Activity)
        Dim baseIdentifier As String = activity.GetType().Name
        Dim b As New StringBuilder(baseIdentifier.Length)
        For i As Integer = 0 To baseIdentifier.Length
            If Char.IsUpper(baseIdentifier(i)) And (i = 0 Or i = baseIdentifier.Length - 1 Or Char.IsUpper(baseIdentifier(i + 1))) Then
                b.Append(Char.ToLower(baseIdentifier(i)))
            Else
                b.Append(baseIdentifier.Substring(i))
                Exit For
            End If
        Next
        Return b.ToString()
    End Function

    Private Shared Function GetRootActivity(ByVal activity As Activity) As Activity
        If activity Is Nothing Then
            Throw New ArgumentException("activity")
        End If

        While activity.Parent IsNot Nothing
            activity = activity.Parent
        End While

        Return activity
    End Function

    Private Shared Function GetAllNestedActivities(ByVal compositeActivity As CompositeActivity) As Activity()

        If compositeActivity Is Nothing Then
            Throw New ArgumentNullException("compositeActivity")
        End If

        Dim nestedActivities As New ArrayList()
        Dim compositeActivities As New Queue()
        compositeActivities.Enqueue(compositeActivity)
        While compositeActivities.Count > 0

            Dim compositeActivity2 As CompositeActivity = CType(compositeActivities.Dequeue(), CompositeActivity)

            For Each activity As Activity In compositeActivity2.Activities
                nestedActivities.Add(activity)
                If activity Is compositeActivity Then
                    compositeActivities.Enqueue(activity)
                End If
            Next

            For Each activity As Activity In compositeActivity2.EnabledActivities
                If Not nestedActivities.Contains(activity) Then
                    nestedActivities.Add(activity)
                    If (activity Is compositeActivity) Then
                        compositeActivities.Enqueue(activity)
                    End If
                End If
            Next
        End While
        Return CType(nestedActivities.ToArray(GetType(Activity)), Activity())
    End Function

備註

注意

此資料討論已被汰換的類型及命名空間。This material discusses types and namespaces that are obsolete. 如需詳細資訊,請參閱 Windows Workflow Foundation 4.5 中即將淘汰的類型For more information, see Deprecated Types in Windows Workflow Foundation 4.5.

IIdentifierCreationService 提供一個在活動範圍內建立唯一名稱識別項的機制。IIdentifierCreationService provides a mechanism to create uniquely named identifiers throughout a range of activities.

方法

EnsureUniqueIdentifiers(CompositeActivity, ICollection) EnsureUniqueIdentifiers(CompositeActivity, ICollection) EnsureUniqueIdentifiers(CompositeActivity, ICollection) EnsureUniqueIdentifiers(CompositeActivity, ICollection)

提供一個確保新增到 CompositeActivity 的活動是唯一名稱的機制。Provides a mechanism to ensure that Activities added to a CompositeActivity are uniquely named.

ValidateIdentifier(Activity, String) ValidateIdentifier(Activity, String) ValidateIdentifier(Activity, String) ValidateIdentifier(Activity, String)

提供一個機制來測試 Activity 中的識別項是唯一的。Provides a mechanism to test that an identifier is unique within an Activity.

適用於