IIdentifierCreationService Interface

 
Note: This API is now obsolete.

Provides a mechanism to create uniquely named identifiers throughout a specified range of activities.

Namespace:   System.Workflow.ComponentModel.Design
Assembly:  System.Workflow.ComponentModel (in System.Workflow.ComponentModel.dll)

[ObsoleteAttribute("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
public interface IIdentifierCreationService

NameDescription
System_CAPS_pubmethodEnsureUniqueIdentifiers(CompositeActivity, ICollection)

Provides a mechanism to ensure that Activities added to a CompositeActivity are uniquely named.

System_CAPS_pubmethodValidateIdentifier(Activity, String)

Provides a mechanism to test that an identifier is unique within an Activity.

System_CAPS_noteNote

This material discusses types and namespaces that are obsolete. For more information, see Deprecated Types in Windows Workflow Foundation 4.5.

IIdentifierCreationService provides a mechanism to create uniquely named identifiers throughout a range of activities.

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

.NET Framework
Available since 3.0
Return to top
Show: