Professional Documents
Culture Documents
Copyright and Trademark Notice Use of the product documented in this guide is subject to your prior acceptance of the End User License Agreement. Information in this document is subject to change without notice. Companies, names, and data used in examples herein are fictitious unless otherwise noted. No part of this document may be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose, without the express written permission of Citrix Systems, Inc. 2006-2009 Citrix Systems, Inc. All rights reserved. Citrix, is a registered trademark of Citrix Systems, Inc. in the United States and other countries. Trademark Acknowledgements Adobe, Acrobat, and PostScript are trademarks or registered trademarks of Adobe Systems Incorporated in the U.S. and/or other countries. Microsoft, Windows, Windows Media, Windows Server, Windows NT, Win32, Outlook, ActiveX, Active Directory, and DirectShow are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other countries. All other trademarks and registered trademarks are the property of their respective owners. Document Code: February 17, 2009 (KP)
C ONTENTS
Contents
Chapter 1
Chapter 2
Chapter 3
Chapter 4
C HAPTER 1
The following topics provide an overview to activity libraries and describe the installation requirements: Overview on page 1 Citrix Tools and Templates on page 2 Activity Library Design Considerations on page 3 Installation and Setup on page 5 Next Steps on page 7
Overview
Workflow Studio, a member of the Citrix Delivery Center product family, is an IT process automation solution that is built on the Microsoft .NET Framework, Windows Workflow Foundation, and Windows PowerShell. Citrix Workflow Studio includes a rehosted and extended version of the Workflow Foundation Designer that provides additional functionality that simplifies the creation of workflows from activities. An activity library is a collection of activities stored as a compiled binary (a .dll). Workflow Studio includes some basic activity libraries, a defined way to extend Microsoft's Workflow Foundation. Citrix is also developing activity libraries that integrate products such as Citrix XenDesktop, XenApp, XenServer, and NetScaler to enable your IT infrastructure to operate as a dynamic delivery platform. Citrix partners are invited and encouraged to create custom activity libraries to take advantage of the benefits of Citrix Workflow Studio. Building a custom activity library for Workflow Studio is similar to building a Workflow Foundation activity library. In fact, you can build a Workflow Foundation activity library and use it in Workflow Studio. However, if you build an activity library as described in this guide, some of the development work is done for you and a workflow developer using your library can take advantage of the Workflow Studio extensions that simplify workflow development and provide functionality targeted to IT administrators. Your custom activity libraries might integrate with your own or third-party products (that have PowerShell snap-ins) to provide functionality such as the following:
Power Management Being able to power on/off both physical and virtual servers automatically provides the ability to better manage your resources and, ultimately, save on costs by having your power-hungry servers off when they are not needed. User Provisioning Every organization has a process for provisioning and de-provisioning user accounts, but often these processes involve multiple manual steps. Automating the process end-to-end ensures that best practices are followed in exactly the same way each time. Dynamic Resource Allocation Transform your data center into a delivery center by creating workflows that tie together your server provisioning process (both physical and virtual) with your web, desktop, and application delivery processes. Your custom activities and workflows can mechanize repetitive configuration processes and coordinate condition-based triggers for administrative tasks. Disaster Recovery Most disaster recovery teams have a binder that lists all the activities that must take place in the face of different events. Automating all your failover scenarios and recovery events is a perfect use case for Workflow Studio. You may not be able to define all the different disasters that might happen but you can define all the different responses. Even better, you can automate the responses and just embed notifications for what the system is doing on your behalf. Product Automation A good place to start is with the little things that bother people. There are lots of opportunities around individual products to offer additional value-add and plenty of opportunity to automate around product quirks. Product automation also ensures that a process implemented around best practices is always performed the same way regardless of who runs the workflow. In addition, Workflow Studio provides a way to react to problems with software deployments automatically and resolve them without the need for user interaction.
Chapter 1
PowerShell Converter
If you have a PowerShell snap-in that you would like to use in Workflow Studio as an activity library, the Citrix PowerShell Converter (a wizard and templates) help automate the process. The Converter wizard inspects the snap-in and lists all of the cmdlets available. After you select the cmdlets you want to use, the wizard generates a project with one activity per cmdlet. The wizard automates much of the activity development process: It sets up all of the references, and adds one class file for each cmdlet selected from the PowerShell snap-in. This automated process also does a reasonable job of inspecting the cmdlet parameters and converting them, but you will want to look through the parameters and the validation logic before you deploy the activities.
Standard Templates
If you want to build an activity library that targets Workflow Studio and does not use PowerShell, our basic Activity Library Project and Item templates help you get started. They set up the necessary project references and generate sample code that is heavily commented with the various parameter and validation options.
Ultimately, the best architecture to use when creating an activity library depends on the APIs that are available for the product you want to access and the skill set of the development team. Because Workflow Studio natively supports PowerShell cmdlets, if a PowerShell library is available for the product you want to integrate with AND that library closely matches the types of activities you would like to expose, using the converter is best. However, any technology that can be accessed from .NET can be used in an activity, so it is not necessary to create a PowerShell library solely for the purpose of translating to an activity library.
Try to identify the most likely automation scenarios (perhaps the top ten) and design around those scenarios. Consider the types of functionality your customer wants to automate and ensure that you are providing the necessary tools. A workflow developer will use your activity libraries, plus other activity libraries, when building a workflow. Take care in naming the activities so that their purpose is obvious, even to a non-developer. And, make sure that the links between the activities needed to accomplish automation are fairly easy to bind together.
Keep in mind that activity libraries are used by workflows.
Ultimately, the design of your activity library will impact the IT administrators who run workflows that use your library. Thus, you need to think in terms of workflows. For example, suppose that you are developing activities related to server maintenance. A common task in working with servers is entering credentials. An administrator should not have to enter server credentials repeatedly to use a workflow. Your activities should be designed so that workflows based on them enable administrators to run the workflow without intervention. What seems to make the most sense to the IT administrator is an architecture that is object-based and provides verbs that operate on those objects. For example, Get-VM retrieves a VM object and Stop-VM requires a VM object to be passed to it.
Consider the optimum scope of activities and activity libraries.
An optimum design maintains a balance between too many specific activities versus too few general activities. When you convert a PowerShell snap-in to an activity library, the converter creates one activity for each selected cmdlet. Depending on the design of the snap-in and your target workflows, you might need to combine several commands into one activity or even separate a generated activity into multiple activities. For example, if the conversion of a PowerShell snap-in results in an activity that is too general and has many properties, you might find it better to make the activity more specific by specifying some of the properties. Suppose that the conversion resulted in an activity called Add that takes a property of the object to be added. You could edit that activity to be more specific (AddItem), prefill some of the properties, and then hide those properties so they do not appear in the Workflow Studio window. Often the APIs that exist for a product are not designed in an optimal way to be used in a workflow. For example, you need to think about the API functions and objects that are typically only used during initial setup or rarely in the life of the product. Related activities would be good candidates to hide by default (in Workflow Studio), put into a separate library, or omit.
Chapter 1
The location of those files does not matter. You will browse to them from the Visual Studio Add Reference dialog box.
Template installer
4. Click Next and then Finish. The links that appear allow you to view the path to the installed files.
Chapter 1
Next Steps
The following topics describe how to create activity libraries from the Citrix-provided templates: Converting PowerShell Snap-ins to Activity Libraries on page 9 Creating Activities from Citrix Templates on page 29
C HAPTER 2
This tutorial covers the tasks related to developing an activity library from a PowerShell snap-in by using the Citrix PowerShell Converter. In this tutorial you will perform the following tasks: Create an activity library project from a PowerShell snap-in. Edit the generated code to add and change references, activity attributes, input/ output base classes, and dependency properties. Review the project properties and change as needed. Add the new activity to Workflow Studio and use it to create a workflow. Understand the requirements for debugging validation logic versus debugging execution logic. Learn best practices for developing activities from PowerShell snap-ins.
This chapter covers the following topics: Creating a Project and Generating Activities on page 10 Editing the Code on page 14 Reviewing Project Properties on page 19 Testing the Activity in a Workflow on page 20 Best Practices on page 23
10
Chapter 2
11
12
Note Notice the Refresh button across from the List Cmdlets button. If you install a
new PowerShell snap-in while the converter is open, you can click Refresh to reload the list. 7. Select the cmdlets that you want to include in the project. For this tutorial, select only Get-Date.
Chapter 2
11. 12.
13
To view the generated code: Right-click GetDate.cs in the Solution Explorer and choose View Code. Notice the using statements in the code.
Support for the customized theme in the Workflow Studio Designer. Custom file browser, folder browser, text editor, and custom binding dialog support. Helper objects to make PowerShell serializable. Base classes you can derive from when building activities to simplify access to PowerShell and WMI. Native tools to support development of UI activities. Those components are also included in the References list in the Visual Studio Solution Explorer.
14
Note Code regions not covered in this tutorial typically do not need modification. For
additional help, refer to the samples and comments in the generated code as well as Best Practices on page 23.
Note: When you do not know which dll to reference, refer to the developer documentation for the snap-in. c. Click OK.
The References list now includes an entry for the added object.
Chapter 2
2.
15
Note: The reference and the using statement names might not match. Refer to the developer documentation for the snap-in if you need help. 3. To set up the ActivityReferenceAssemblies attribute on the project: a. Open the Attribute Definitions and Comments region and copy the following commented line to the end of the attribute definitions:
You will need to replace the fully specified assembly name (everything inside of the double-quotes) with the information for the added assembly. A PowerShell command provides access to that information, as follows. b. Uncomment the line, open a PowerShell window, and run the following PowerShell command: A list of assembly names appears. c. From that list, copy the entire line that starts with Microsoft.PowerShell.Commands.Utility and paste it in your code between the double-quotes. The attribute will now look similar to the following:
Activity Attributes
The Attribute Definitions region contains the following generated code. These attributes define characteristics of the activity when it is used in Workflow Studio Designer.
[Designer(typeof(BaseActivityDesigner))] [DisplayNameAttribute("Get-Date")] [Description(@"Gets the current date and time.")] [ActivityTreePath(@"Windows PowerShell/Utilities")] [ActivityValidator(typeof(GetDateValidator))] [ToolboxBitmapAttribute(typeof(GetDate), @"Resources.GetDate16.png")] [BaseActivityDesigner(ImageResourceName = @"Resources.GetDate32.png", AssemblyType = typeof(GetDate))] [CTXPSCmdletInfoAttribute("Get-Date","Microsoft.PowerShell.Utility")] [ActivityReferenceAssemblies(new string[] { "Microsoft.PowerShell.Commands.Utility, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" })]
16
There are no other changes that you need to make to the attributes for this tutorial. You generally will only need to change the two icon filenames and add/edit the ActivityReferenceAssemblies line. Be aware that the following attributes, not added by the template, are also available. You can copy them from the comment block. They are also detailed in General Activity Attributes on page 35 and PowerShell-Specific Activity Attributes on page 38. ActivityReferenceAssemblies Specifies other assemblies to be referenced by a workflow using this activity. (You added this attribute earlier in this tutorial.) BindTypesOverride Allows you to specify additional data types to which the Input or Output properties can be bound. CTXPSParameterInfo Maps activity properties to PowerShell parameters.
Chapter 2
17
DesignerSerializer Calls the Citrix BindingListSerializer. This attribute is required if your activity includes bindable properties. HiddenPSSnap-in Specifies a PowerShell snap-in to be dynamically loaded at runtime.
//[Description("<enter new description>")] //[Category("Parameters")] //[Browsable(true)] //[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)] //public override Object Input //{ // // get { return base.Input; } set { base.Input = value; }
2. 3.
Delete the Description and Category attributes. They are not needed for a hidden input property. Change the Browsable attribute to false so that the Input property for GetDate will not appear in the properties list. The input base class should now contain the following lines:
[Browsable(false)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)] public override Object Input { get { return base.Input; } set { base.Input = value; } }
18
Dependency Properties
A dependency property is a property to which other activities can bind. They are the properties used by the cmdlet that you converted. When this activity is added to Workflow Studio, the dependency properties will appear in the right pane of the designer window (under Parameters) when you select the GetDate activity. The GetDate activity you are creating does not need bindable properties, so you will remove most of them.
Chapter 2
19
Note For activities that you plan to release publicly, you should replace the key file
with your own. 4. If you change any properties, right-click the GetDate tab and choose Save Selected Items.
20
2.
Chapter 2
3.
21
To install the activity library in Workflow Studio: a. b. Choose Tools > Choose Activities. Click Browse, navigate to Program Files\Citrix\Workflow Studio, select GetDate.dll, and click Open.
4.
To add the GetDate activity to the Activities tab: In the Choose Activities dialog box, select the checkbox of the GetDate activity, and then click OK.
5.
Add the following two activities to the workflow: a. b. In the Activities tab, open the Windows PowerShell > Utilities folder. It contains one activity, GetDate. Drag GetDate to the design surface. In the Activities tab, open the Workflow Control > Debugging folder and drag MessageBox to the design surface under GetDate.
To add the output of the GetDate activity to that text, select Output (under the getDate1 activities) and then click Add.
22
Chapter 2
23
Best Practices
Best practices for creating an activity from a PowerShell snap-in follow.
Note Although the core of Workflow Foundation is very strict about data types,
Workflow Studio extensions reduce what you need to know about data types and conversion. Uncomment the EditorAttribute, which is used for strings. Search for properties with CTXPSParameterInfoAttribute.CTXAttributeType.Unknown and replace Unknown with a type that makes sense for the object (most likely it will be Object). The Unknown type is specifically included to throw a runtime error and remind you to look at it. Include additional design time and run time validation based on the integer range expected to ensure that the entry is a valid integer in the correct range.
24
#region Year Property public static DependencyProperty YearProperty = DependencyProperty.Register("Year", typeof(String), typeof(GetDate)); [DisplayName("Year")] [Description("Specifies the year that is displayed. Enter a value from 1 - 9999. This value is displayed instead of the current year.")] [Category("Parameters")] [Browsable(true)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)] [EditorAttribute(typeof(TextEditor), typeof(UITypeEditor))] [CTXPSParameterInfo("Year", AttributeType = CTXPSParameterInfoAttribute.CTXAttributeType.Int32)] //[BindTypes(new Type[] { typeof(Int32)} )] public String Year { get { return ((String)(base.GetValue(GetDate.YearProperty))); } set { base.SetValue(GetDate.YearProperty, value); } }
Chapter 2
25
From the Resources tab, you can create a resources file and add the images to it. In the generated code, update the filenames in the following lines:
The default images are provided as part of the base Workflow Foundation. You will not find those images in the Workflow Studio application folders.
26
Other Considerations
Use the correct process when debugging custom activities
When you need to debug an activity that will be used in Workflow Studio, you should follow the standard Microsoft debugging principles. The only thing specific to Workflow Studio that you need to be aware of is the difference between debugging the validation logic and debugging the execution logic. You must attach Visual Studio to the correct Workflow Studio process, as follows. Connect Visual Studio to this process... wfs.exe
To debug... Validation logic (which runs at design time, such as when you specify a property) Execution logic (for a workflow run when you click Start in the Workflow Studio Designer) Execution logic (for a deployed workflow or job)
WorkflowExpressRuntime.exe
WorkflowRuntimeHostService.exe
Chapter 2
27
user.Config This user setting must be changed to update the list in the Workflow Studio Choose Activities dialog box.
Note You can also reset the activity library to its default, thus removing all activities
that you have added, by deleting those configuration files. However, your SQL server domain name and any other configuration changes you made will be lost.
28
The Name is generated from the PowerShell snap-in name by removing the hyphen from the name (because hyphens are not supported in activity names in Workflow Foundation). For example, if you create an activity from the Get-Date snap-in, the generated name is as follows:
this.Name = GetDate;
If the generated name begins with an upper case letter (GetDate), the first time you drag the GetDate activity to the Workflow Studio design surface, the activity name will have a 1 appended (GetDate1). The number is incremented for subsequent uses (GetDate2, GetDate3). If the generated name begins with a lower case letter (getDate), the first time you drag the GetDate activity to the Workflow Studio design surface, the activity name will match the generated name (getDate). A number is appended for subsequent uses (getDate1, getDate2).
C HAPTER 3
This tutorial covers the tasks related to creating an activity by using the Citrix Standard Activity template for Visual Studio. This tutorial assumes that you have completed the tutorial in Converting PowerShell Snap-ins to Activity Libraries on page 9. This chapter covers the following topics: Creating an Activity from a Citrix Template on page 29 Editing the Code on page 31 Testing the Standard Activity in a Workflow on page 33
30
Chapter 3
3.
31
To view the code: Select AdvancedDelay.cs in the Solution Explorer and choose View > Code.
Activity Attributes
The Attribute Definitions region contains the following generated code. You will change the activity description and its location in the Workflow Studio Designer activity tree.
[Designer(typeof(BaseActivityDesigner))] [DisplayNameAttribute(@"AdvancedDelay")] [Description(@"This activity will <...>.")] [ActivityTreePath(@"Folder/SubFolder")] [ActivityValidator(typeof(AdvancedDelayValidator))] [ToolboxBitmapAttribute(typeof(AdvancedDelay), @"Resources.AdvancedDelay16.png")] [BaseActivityDesigner(ImageResourceName = @"Resources.AdvancedDelay32.png", AssemblyType = typeof(AdvancedDelay))]
2.
Constructor
To define the default value for the delay activity
1. In the Constructor region, uncomment the line:
\\this.IntegerProp = 0;
2.
Dependency Properties
You will uncomment a sample dependency property and edit it to correctly reference DelayTimeProp.
32
//public static DependencyProperty IntegerPropProperty = DependencyProperty.Register("IntegerProp", typeof(Int32), typeof(AdvancedDelay)); //[DefaultValue("0")] //[Category(@"Parameters")] //[DisplayName(@"DependencyIntegerProperty")] //[Description(@"Description.")] //[Browsable(true)] //[InputAttribute] //public Int32 IntegerProp //{ // // // // // // // // //} } } set { base.SetValue(IntegerPropProperty, value); get { return ((Int32)(base.GetValue(IntegerPropProperty)));
2.
3. 4. 5. 6. 7.
Change the DisplayName value to DelayTime. Change the Description value to Specifies the amount of time to delay (in ms). Change public Int32 IntegerProp to public Int32 DelayTimeProp Change return ((Int32)(base.GetValue(IntegerPropProperty) to return ((Int32)(base.GetValue(DelayTimePropProperty) Change base.SetValue(IntegerPropProperty, value); to base.SetValue(DelayTimePropProperty, value);
Chapter 3
33
Validation Logic
You will uncomment sample property validation and edit it to correctly reference DelayTimeProp. 1. Under Sample Property Validation, uncomment this line:
//if (!GlobalUtilities.Int32Validates(MyActivity.IntegerProp)
2.
if (!GlobalUtilities.Int32Validates(MyActivity.DelayTimeProp.ToString()))
3.
//errs.Add(new ValidationError(@"You must specify a value for the 'IntegerProp' property.", 101, false, @"IntegerProp"));
4.
errs.Add(new ValidationError(@"You must specify a value for the 'DelayTimeProp' property.", 101, false, @"DelayTimeProp"));
34
C HAPTER 4
The following topics describe the Workflow Studio activity attributes: General Activity Attributes on page 35 PowerShell-Specific Activity Attributes on page 38 Dependency Property Attributes on page 39 PowerShell-Specific Property Attribute on page 41
[Designer(typeof(BaseActivityDesigner))]
Defines what activity designer will be used for the current activity. The BaseActivityDesigner is the Citrix designer, which renders an activity as follows:
36
[DisplayNameAttribute(@"name")]
Attribute allows you to specify the name for your activity. This is the name that will appear in the toolbox, and the same name that will appear on the activity in the design surface when dropped there. Any spaces in this name will be replaced with underscore characters when the activity is dropped on the design surface.
[Description(@"text")]
Allows you to provide a brief text description of the activity. This text will appear at the bottom of the toolbox in the Workflow Designer console when the activity is selected in the toolbox. Typically, this text is short and simply gives a high-level overview of what the task does.
[ActivityTreePath(@"path/name")]
Allows you to specify where you want this activity to appear in the toolbox. This is essentially the folder name. Note, use forward-slashes, not back-slashes, to separate folders in the path, if you have nested folders.
[ActivityValidator(typeof(CreateVMValidator))]
Defines which class is responsible for the validation logic of the activity. Typically each activity has its own, dedicated validator class and, if the provided activity template is used, will reside at the bottom of the activity .cs file.
[ToolboxBitmapAttribute(typeof(CreateVM), @"name.png")]
Allows you to specify the 16x16 image file to use as the icon for the activity in the toolbox (tree view). The image must be a .png file. The image does not need to be the exact same image as that supplied in the BaseActivityDesigner attribute, but usually is.
Chapter 4
37
[DesignerSerializer(typeof(BindingListSerializer), typeof(WorkflowMarkupSerializer))]
If you have any BindingList<> properties in this activity your activity needs to declare a DesignerSerializer attribute calling the Citrix BindingListSerializer.
[BindTypesOverride("Input", new Type[] { typeof(String) })] [BindTypesOverride("Output", new Type[] { typeof(String) })]
Allows you to specify additional data types to which the Input or Output properties can be bound.
38
[CTXPSCmdletInfoAttribute(@"cmdlet", @"snapIn")]
Allows you to specify the Powershell cmdlet that an activity runs. This attribute is applicable to activity classes that inherit from PSActivityBase. PSActivityBase::Execute will execute the specified Powershell cmdlet, with the parameters specified by the CTXPSParameterInfo attributes. The first parameter is the cmdlet name. The second (optional) parameter is the snap-in name. If a snap-in name is specified, that snap-in will be loaded in the runspace before the cmdlet is called).
[HiddenPSSnapIn("assemblyName")]
Allows you to specify a Powershell snap-in to be dynamically loaded at runtime. This allows you to use Powershell cmdlets that are not defined in a registered PSSnapin on the computer. It takes one parameter, which is expected to be the full name of the assembly. For example: [HiddenPSSnapIn("XenAppCmdlets, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")] The assembly is loaded, and any cmdlets within it are dynamically added to the runspace. This attribute applies to activity classes that inherit from PSActivityBase.
Chapter 4
39
[DefaultValue(@"")]
Allows you to specify a value that the property grid will identify as the default value. If supplied, default values appear as normal text and when the value is changed from the default the value appears as bold text. Note: The actual default value for a dependency property must be set in the constructor for the activity class. This attribute simply alters the behavior of the property in the property grid.
[Category(@"Parameters")]
Allows you to specify the group within the property grid where you want the property to appear. The normal default for Workflow Studio activities is Parameters. Consider placing parameters that are optional under a different category.
[DisplayName(@"Message Text")]
Allows you to specify the name of the property as it will appear in the property grid (in the left-hand column of the property grid).
[Browsable(true)]
Allows you to specify whether the property will appear in the property grid. If omitted, the property will be displayed. If supplied and the attribute value set to false, the property will not be displayed.
40
[InputAttribute]
Allows you to specify whether the property is an input type of property. Using this attribute simply puts an input icon next to the property in the binding drop-down. Note: If this attribute is include, the OutputAttribute should not be included.
[OutputAttribute]
Allows you to specify whether the property is an output type of property. Output properties receive a special output icon next to the property in the binding drop-down, and they will always appear in the TextEditor editor, regardless of their data type. Note: If this attribute is included, the InputAttribute should not be included.
[EditorAttribute(typeof(TextEditor), typeof(UITypeEditor))]
Allows you to specify which property editors, if any, are associated with this property. Any editor can be used, but the following is a list of available editors included with Workflow Studio: BindingDropDownListEditor DropDownList DSComputerPicker DSGroupPathPicker DSObjectPathPicker DSOUPicker EditorHelper FileWithConstructor FolderWithConstructor NamedCollectionEditor OpenFileEditor OpenFolderEditor PasswordEditor PropertyColumnEditor StringEdit StringWithConstructor TextEditor TrusteeEditor VariableEdit
[ReadOnly(true)]
Allows you to specify whether the property value is allowed to change. Setting the ReadOnly attribute value to true will restrict the value from being changed by the user.
[DesignerSerializationVisibility(DesignerSerializationVisibility. Visible)]
System.ComponentModel.DesignerSerializationVisibilityAttribute specifies what part of a property should be serialized by the designer. This attribute is usually necessary when creating custom Web and Windows controls. This attribute takes one parameter, which is a System.ComponentModel.DesignerSerializationVisibility enumeration member:
Visible Specifies that the object should be serialized. Use this value for simple (or primitive) properties.
Chapter 4
41
Content Specifies that contents of the object should be serialized. Use this value for complex (or non-primitive) properties and collections. Hidden Specifies that the object should not be serialized. Use this value when properties are changed for design-time purposes only, but should not be serialized in code.
In Workflow Studio, this attribute is used for most properties to ensure proper serialization during design time.
[ShowInWFSEditors]
Allows you to override the Browsable attribute to cause properties to show up in the TextEditor editor, even though they may be hidden in the property grid itself.
42