protected override void PerformFlush(IDesignerSerializationManager manager) { IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost)); if (host != null && host.RootComponent != null) { Activity rootActivity = host.RootComponent as Activity; if (rootActivity != null) { StringWriter writer = new StringWriter(); try { using (XmlWriter xmlWriter = XmlWriter.Create(writer)) { WorkflowMarkupSerializer xamlSerializer = new WorkflowMarkupSerializer(); xamlSerializer.Serialize(xmlWriter, rootActivity); } } finally { writer.Close(); } Xaml = writer.ToString(); } } }
private void LoadDefFromReader(SqlDataReader reader, object parameter) { if (reader == null) { throw new ArgumentNullException("reader"); } if (!reader.Read()) { throw new ArgumentException(ExecutionStringManager.InvalidDefinitionReader); } StringReader input = new StringReader(reader.GetString(0)); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); DesignerSerializationManager serializationManager = new DesignerSerializationManager(); IList errors = null; try { using (serializationManager.CreateSession()) { using (XmlReader reader3 = XmlReader.Create(input)) { this._def = serializer.Deserialize(serializationManager, reader3) as Activity; errors = serializationManager.Errors; } } } finally { input.Close(); } if ((this._def == null) || ((errors != null) && (errors.Count > 0))) { throw new WorkflowMarkupSerializationException(ExecutionStringManager.WorkflowMarkupDeserializationError); } }
public static WorkflowTheme Load(IDesignerSerializationManager serializationManager, string themeFilePath) { if (serializationManager == null) { throw new ArgumentNullException("serializationManager"); } WorkflowTheme theme = null; if ((themeFilePath != null) && File.Exists(themeFilePath)) { XmlReader reader = XmlReader.Create(themeFilePath); ThemeSerializationProvider provider = new ThemeSerializationProvider(); try { serializationManager.AddSerializationProvider(provider); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); theme = serializer.Deserialize(serializationManager, reader) as WorkflowTheme; } finally { serializationManager.RemoveSerializationProvider(provider); reader.Close(); } if (theme != null) { theme.filePath = themeFilePath; } } return(theme); }
public void EditCommon(object sender, EventArgs e) { RuleSet ruleSet = null; XmlTextReader rulesReader = new XmlTextReader("Common.rules"); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); ruleSet = (RuleSet)serializer.Deserialize(rulesReader); rulesReader.Close(); RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(keyHandlerState), null, ruleSet); DialogResult result = ruleSetDialog.ShowDialog(); ruleSet = ruleSetDialog.RuleSet; if (result == DialogResult.OK) { // Serialize to a .rules file serializer = new WorkflowMarkupSerializer(); XmlWriter rulesWriter = XmlWriter.Create("Common.rules"); serializer.Serialize(rulesWriter, ruleSet); rulesWriter.Close(); } }
private RuleSet GetPromotionRuleSet(string expressionPlace, string expressionKey) { RuleSet retVal = null; int expressionId = Int32.Parse(expressionKey); if (expressionId > 0) { if (DataSource == null) { throw new NullReferenceException("DataSource is null"); } ExpressionDto dto = GetDataSourceDto(DataSource); ExpressionDto.ExpressionRow row = dto.Expression.FindByExpressionId(expressionId); if (row != null) // new one { StringReader stringReader = new StringReader(row.ExpressionXml); XmlTextReader reader = new XmlTextReader(stringReader); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); retVal = serializer.Deserialize(reader) as RuleSet; } } return(retVal); }
private static RuleSet DeserializeRuleSet(string ruleSetXml, string fullPath) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); if (!string.IsNullOrEmpty(ruleSetXml)) { StringReader stringReader = new StringReader(ruleSetXml); XmlTextReader reader = new XmlTextReader(stringReader); RuleSet ruleSet = null; try { ruleSet = serializer.Deserialize(reader) as RuleSet; } catch (WorkflowMarkupSerializationException ex) { throw new ToolkitException(string.Format(CultureInfo.CurrentCulture, Resources.invalidRuleSetFormat, fullPath), ex); } return(ruleSet); } else { return(null); } }
public virtual XmlQualifiedName GetXmlQualifiedName(Type type, out string prefix) { if (type == null) { throw new ArgumentNullException("type"); } string typeNamespace = type.Namespace ?? String.Empty; string assemblyName = (type.Assembly != null && type.Assembly != this.localAssembly) ? type.Assembly.FullName : String.Empty; int key = typeNamespace.GetHashCode() ^ assemblyName.GetHashCode(); if (!this.clrNamespaceBasedMappings.TryGetValue(key, out WorkflowMarkupSerializerMapping mappingForType)) { WorkflowMarkupSerializerMapping.GetMappingFromType(this, type, out mappingForType, out IList <WorkflowMarkupSerializerMapping> collectedMappings); AddMappings(new List <WorkflowMarkupSerializerMapping>(new WorkflowMarkupSerializerMapping[] { mappingForType })); AddMappings(collectedMappings); } string typeName = WorkflowMarkupSerializer.EnsureMarkupExtensionTypeName(type); //Make sure that while writting the workflow namespaces will always be the default prefix = (mappingForType.Prefix.Equals(StandardXomlKeys.WorkflowPrefix, StringComparison.Ordinal)) ? String.Empty : mappingForType.Prefix; return(new XmlQualifiedName(typeName, mappingForType.XmlNamespace)); }
public void GetRuleDefinitions() { var serializer = new WorkflowMarkupSerializer(); _ruleDefinitions = new RuleDefinitions(); Parallel.For(0, _rulesStream.Count, streamCounter => { using (XmlReader reader = new XmlTextReader(_rulesStream[streamCounter])) { var temp = serializer.Deserialize(reader) as RuleDefinitions; if (temp == null) { return; } if (temp.RuleSets != null) { for (int i = 0; i < temp.RuleSets.Count; i++) { _ruleDefinitions.RuleSets.Add(temp.RuleSets[i]); } } if (temp.Conditions != null) { for (int i = 0; i < temp.Conditions.Count; i++) { _ruleDefinitions.Conditions.Add(temp.Conditions[i]); } } } }); }
protected override void PerformLoad(IDesignerSerializationManager serializationManager) { IDesignerHost designerHost = (IDesignerHost)GetService(typeof(IDesignerHost)); Activity rootActivity = null; //First see if we have a workflow type if (WorkflowType != null) { rootActivity = (Activity)Activator.CreateInstance(WorkflowType); } else { // Create a text reader out of the doc data, and ask TextReader reader = new StringReader(this.xamlValue); try { using (XmlReader xmlReader = XmlReader.Create(reader)) { WorkflowMarkupSerializer xamlSerializer = new WorkflowMarkupSerializer(); rootActivity = xamlSerializer.Deserialize(xmlReader) as Activity; } } finally { reader.Close(); } } if (rootActivity != null && designerHost != null) { AddObjectGraphToDesignerHost(designerHost, rootActivity); } }
private void OpenXamlInNotepad(object sender, EventArgs e) { ToolStripMenuItem item = (ToolStripMenuItem)sender; WorkflowNode node = (WorkflowNode)item.Tag; object workflowInstance = null; try { workflowInstance = node.WorkflowType.InvokeMember(string.Empty, BindingFlags.CreateInstance, null, null, null, CultureInfo.InvariantCulture); } catch (Exception exc) { MessageBox.Show("The workflow type could not be created: " + exc.ToString()); return; } WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); string tempFileName = Path.GetTempFileName(); using (XmlWriter xmlWriter = XmlWriter.Create(tempFileName)) { serializer.Serialize(xmlWriter, workflowInstance); } ProcessStartInfo psi = new ProcessStartInfo(); psi.Arguments = tempFileName; psi.FileName = Path.Combine(Environment.GetEnvironmentVariable("windir"), "notepad.exe"); Process.Start(psi); }
/// <summary> /// Replace the entire rule definition for a workflow /// </summary> /// <param name="instance"></param> private static void ReplaceRuleDefinition(WorkflowInstance instance) { //create a workflow changes object WorkflowChanges wfChanges = new WorkflowChanges( instance.GetWorkflowDefinition()); //get a stream from an externally saved .rules file Stream stream = new FileStream(@"ModifiedRule.rules", FileMode.Open, FileAccess.Read, FileShare.Read); //read the .rules file using an XmlReader using (XmlReader xmlReader = XmlReader.Create( new StreamReader(stream))) { WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); //deserialize the rule definitions RuleDefinitions ruleDefinitions = markupSerializer.Deserialize(xmlReader) as RuleDefinitions; if (ruleDefinitions != null) { //replace the embedded rules definition //with the new one that was deserialzed from a file wfChanges.TransientWorkflow.SetValue( RuleDefinitions.RuleDefinitionsProperty, ruleDefinitions); ValidateAndApplyChanges(instance, wfChanges); } } }
public static RuleSet Deserialize(string xml) { using (XmlReader rulesReader = XmlReader.Create(new StringReader(xml))) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); return((RuleSet)serializer.Deserialize(rulesReader)); } }
public static void Serialize(RuleSet ruleset, StringBuilder sb) { using (XmlWriter rulesWriter = XmlWriter.Create(sb)) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); serializer.Serialize(rulesWriter, ruleset); } }
public void WriteXml(System.Xml.XmlWriter writer) { if (RuleSet != null) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); serializer.Serialize(writer, RuleSet); } }
internal static RuleDefinitions GetRuleDefinitionsFromManifest(Type workflowType) { if (workflowType == null) { throw new ArgumentNullException("workflowType"); } RuleDefinitions definitions = null; if (cloneableOrNullRulesResources.ContainsKey(workflowType)) { definitions = (RuleDefinitions)cloneableOrNullRulesResources[workflowType]; if (definitions != null) { definitions = definitions.Clone(); } return(definitions); } string name = workflowType.Name + ".rules"; Stream manifestResourceStream = workflowType.Module.Assembly.GetManifestResourceStream(workflowType, name); if (manifestResourceStream == null) { manifestResourceStream = workflowType.Module.Assembly.GetManifestResourceStream(name); } if (manifestResourceStream != null) { using (StreamReader reader = new StreamReader(manifestResourceStream)) { using (XmlReader reader2 = XmlReader.Create(reader)) { definitions = new WorkflowMarkupSerializer().Deserialize(reader2) as RuleDefinitions; } } } if (!uncloneableRulesResources.ContainsKey(workflowType)) { try { RuleDefinitions definitions2 = definitions; if (definitions != null) { definitions = definitions.Clone(); } lock (cloneableOrNullRulesResources) { cloneableOrNullRulesResources[workflowType] = definitions2; } } catch (Exception) { lock (uncloneableRulesResources) { uncloneableRulesResources[workflowType] = null; } } } return(definitions); }
// This function will create a new root activity definition tree by deserializing the xoml and the rules file. protected internal override Activity CreateInstance(XmlReader workflowDefinitionReader, XmlReader rulesReader) { if (workflowDefinitionReader == null) { throw new ArgumentNullException("workflowDefinitionReader"); } Activity root = null; ValidationErrorCollection errors = new ValidationErrorCollection(); ServiceContainer serviceContainer = new ServiceContainer(); ITypeProvider typeProvider = this.Runtime.GetService <ITypeProvider>(); if (typeProvider != null) { serviceContainer.AddService(typeof(ITypeProvider), typeProvider); } DesignerSerializationManager manager = new DesignerSerializationManager(serviceContainer); try { using (manager.CreateSession()) { WorkflowMarkupSerializationManager xomlSerializationManager = new WorkflowMarkupSerializationManager(manager); root = new WorkflowMarkupSerializer().Deserialize(xomlSerializationManager, workflowDefinitionReader) as Activity; if (root != null && rulesReader != null) { object rules = new WorkflowMarkupSerializer().Deserialize(xomlSerializationManager, rulesReader); root.SetValue(ConditionTypeConverter.DeclarativeConditionDynamicProp, rules); } foreach (object error in manager.Errors) { if (error is WorkflowMarkupSerializationException) { errors.Add(new ValidationError(((WorkflowMarkupSerializationException)error).Message, ErrorNumbers.Error_SerializationError)); } else { errors.Add(new ValidationError(error.ToString(), ErrorNumbers.Error_SerializationError)); } } } } catch (Exception e) { errors.Add(new ValidationError(e.Message, ErrorNumbers.Error_SerializationError)); } if (errors.HasErrors) { throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors); } return(root); }
/// <summary> /// Saves the expression. /// </summary> /// <param name="set">The set.</param> /// <param name="expressionId">The expression id.</param> protected virtual void SaveExpression(RuleSet set, int expressionId) { if (set == null) { throw new ArgumentNullException("RuleSet"); } if (DataSource == null) { throw new ArgumentNullException("DataSource"); } ExpressionDto dto = GetDataSourceDto(DataSource); ExpressionDto.ExpressionRow row = dto.Expression.FindByExpressionId(expressionId); if (row == null /*&& (expressionId == 0 || dto.Expression.Count == 0)*/) // new one { row = dto.Expression.NewExpressionRow(); row.Name = set.Name; row.Description = String.Empty; row.ApplicationId = MarketingConfiguration.Instance.ApplicationId; row.Category = ExpressionCategory.CategoryKey.Segment.ToString(); row.Created = DateTime.UtcNow; } else { row.Modified = DateTime.UtcNow; } // Serialize ruleset StringBuilder ruleDefinition = new StringBuilder(); #region Serialize StringWriter stringWriter = new StringWriter(ruleDefinition, CultureInfo.InvariantCulture); XmlTextWriter writer = new XmlTextWriter(stringWriter); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); serializer.Serialize(writer, set); #endregion #region Cleanup writer.Flush(); writer.Close(); stringWriter.Flush(); stringWriter.Close(); #endregion row.ExpressionXml = ruleDefinition.ToString(); if (row.RowState == System.Data.DataRowState.Detached) { dto.Expression.Rows.Add(row); } }
/// <summary> /// Deserialize the markup file /// </summary> /// <param name="fileName"></param> /// <returns></returns> private Activity DeserializeFromMarkup(String fileName) { Activity workflow = null; //construct a serialization manager. DesignerSerializationManager dsm = new DesignerSerializationManager(); using (dsm.CreateSession()) { using (XmlReader xmlReader = XmlReader.Create(fileName)) { //deserialize the workflow from the XmlReader WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); workflow = markupSerializer.Deserialize( dsm, xmlReader) as Activity; if (dsm.Errors.Count > 0) { WorkflowMarkupSerializationException error = dsm.Errors[0] as WorkflowMarkupSerializationException; throw error; } } //deserialize a .rules file is one exists String rulesFileName = GetRulesFileName(fileName); if (File.Exists(rulesFileName)) { //read the .rules file using (XmlReader xmlReader = XmlReader.Create(rulesFileName)) { WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); //deserialize the rule definitions RuleDefinitions ruleDefinitions = markupSerializer.Deserialize(dsm, xmlReader) as RuleDefinitions; if (ruleDefinitions != null) { //add the rules definitions to the workflow workflow.SetValue( RuleDefinitions.RuleDefinitionsProperty, ruleDefinitions); } } } } return(workflow); }
public void SaveRuleSet() { RuleDefinitions ruleDefinitions = new RuleDefinitions(); ruleDefinitions.RuleSets.Add(createRuleSet); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlTextWriter writer = new XmlTextWriter("RackRateRules.rules", System.Text.Encoding.Unicode); serializer.Serialize(writer, ruleDefinitions); writer.Close(); }
public void ReadXml(System.Xml.XmlReader reader) { if (!reader.IsEmptyElement) { string ruleSetXml = reader.ReadInnerXml(); XmlReader innerReader = XmlReader.Create(new StringReader(ruleSetXml)); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); RuleSet = serializer.Deserialize(innerReader) as RuleSet; } }
public TransformingMessageServiceBehavior(string ruleSet) { if (!string.IsNullOrWhiteSpace(ruleSet)) { _ruleSetPath = ruleSet; WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlTextReader reader = new XmlTextReader(_ruleSetPath); RuleDefinitions rules = serializer.Deserialize(reader) as RuleDefinitions; _ruleSet = rules.RuleSets[0]; } }
/// <summary> /// Gets workflow markup string from the object. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="obj">The obj.</param> /// <returns></returns> public static string GetString <T>(T obj) { StringBuilder sbOutput = new StringBuilder(1024); using (XmlWriter writer = XmlWriter.Create(sbOutput)) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); serializer.Serialize(writer, obj); } return(sbOutput.ToString()); }
static void SaveRules(RuleSet ruleSet, string ruleFilePath) { // Serialize to a .rules file WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlWriter rulesWriter = XmlWriter.Create(ruleFilePath); serializer.Serialize(rulesWriter, ruleSet); rulesWriter.Close(); }
static RuleSet GetRuleSet(string ruleFilePath) { // De-serialize from a .rules file. using (XmlTextReader rulesReader = new XmlTextReader(ruleFilePath)) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); var ruleSet = (RuleSet)serializer.Deserialize(rulesReader); rulesReader.Close(); return(ruleSet); } }
/// <summary> /// 克隆一个实例 /// </summary> /// <param name="WfRuntimeClone"></param> /// <param name="instanceClone"></param> /// <param name="WfRuntime"></param> /// <returns></returns> public static WorkflowInstance CloneWorkflowInstance(WorkflowRuntime WfRuntimeClone, WorkflowInstance instanceClone, WorkflowRuntime WfRuntime) { try { if (!WfRuntimeClone.IsStarted) { WfRuntimeClone.StartRuntime(); } StateMachineWorkflowInstance workflowinstance = new StateMachineWorkflowInstance(WfRuntimeClone, instanceClone.InstanceId); System.Workflow.Activities.StateMachineWorkflowActivity smworkflow = new StateMachineWorkflowActivity(); smworkflow = workflowinstance.StateMachineWorkflow; RuleDefinitions ruleDefinitions = smworkflow.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions; WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); StringBuilder xoml = new StringBuilder(); StringBuilder rule = new StringBuilder(); XmlWriter xmlWriter = XmlWriter.Create(xoml); XmlWriter ruleWriter = XmlWriter.Create(rule); markupSerializer.Serialize(xmlWriter, smworkflow); if (ruleDefinitions != null) { markupSerializer.Serialize(ruleWriter, ruleDefinitions); } xmlWriter.Close(); ruleWriter.Close(); StringReader readxoml = new StringReader(xoml.ToString()); XmlReader readerxoml = XmlReader.Create(readxoml); WorkflowInstance instance; if (ruleDefinitions == null) { instance = WfRuntime.CreateWorkflow(readerxoml); } else { StringReader readrule = new StringReader(rule.ToString()); XmlReader readerrule = XmlReader.Create(readrule); instance = WfRuntime.CreateWorkflow(readerxoml, readerrule, null); } instance.Start(); return(instance); } catch (Exception ex) { LogHelper.WriteLog("CloneWorkflowInstance异常信息 :" + ex.ToString()); throw new Exception(ex.Message); } }
protected internal override Activity CreateInstance(XmlReader workflowDefinitionReader, XmlReader rulesReader) { if (workflowDefinitionReader == null) { throw new ArgumentNullException("workflowDefinitionReader"); } Activity activity = null; ValidationErrorCollection errors = new ValidationErrorCollection(); ServiceContainer container = new ServiceContainer(); ITypeProvider service = base.Runtime.GetService <ITypeProvider>(); if (service != null) { container.AddService(typeof(ITypeProvider), service); } DesignerSerializationManager manager = new DesignerSerializationManager(container); try { using (manager.CreateSession()) { WorkflowMarkupSerializationManager serializationManager = new WorkflowMarkupSerializationManager(manager); activity = new WorkflowMarkupSerializer().Deserialize(serializationManager, workflowDefinitionReader) as Activity; if ((activity != null) && (rulesReader != null)) { object obj2 = new WorkflowMarkupSerializer().Deserialize(serializationManager, rulesReader); activity.SetValue(ConditionTypeConverter.DeclarativeConditionDynamicProp, obj2); } foreach (object obj3 in manager.Errors) { if (obj3 is WorkflowMarkupSerializationException) { errors.Add(new ValidationError(((WorkflowMarkupSerializationException)obj3).Message, 0x15b)); } else { errors.Add(new ValidationError(obj3.ToString(), 0x15b)); } } } } catch (Exception exception) { errors.Add(new ValidationError(exception.Message, 0x15b)); } if (errors.HasErrors) { throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors); } return(activity); }
private void LoadChangesFromReader(SqlDataReader reader, object parameter) { if (!reader.Read()) { return; } // // Reset the min to the most recent change event DateTime tmpDT = _changesMinDT; if (!reader.IsDBNull(0)) { tmpDT = reader.GetDateTime(0); } if (reader.NextResult()) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); DesignerSerializationManager serializationManager = new DesignerSerializationManager(); while (reader.Read()) { IList errors = null; using (StringReader sr = new StringReader(reader.GetString(0))) { using (serializationManager.CreateSession()) { using (XmlReader xmlReader = XmlReader.Create(sr)) { ActivityChangeAction aAction = serializer.Deserialize(serializationManager, xmlReader) as ActivityChangeAction; errors = serializationManager.Errors; if (null != aAction) { aAction.ApplyTo(_def); } else { throw new WorkflowMarkupSerializationException(ExecutionStringManager.WorkflowMarkupDeserializationError); } } } } } } if (tmpDT > _changesMinDT) { _changed = true; _changesMinDT = tmpDT; } }
/// <summary> /// Deserializes the rule set. /// </summary> /// <param name="ruleSetXmlDefinition">The rule set XML definition.</param> /// <returns></returns> private RuleSet DeserializeRuleSet(string ruleSetXmlDefinition) { if (!String.IsNullOrEmpty(ruleSetXmlDefinition)) { WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); StringReader stringReader = new StringReader(ruleSetXmlDefinition); XmlTextReader reader = new XmlTextReader(stringReader); return(serializer.Deserialize(reader) as RuleSet); } else { return(null); } }
/// <summary> /// Serializes the given ruleset into Xml Format /// </summary> /// <param name="ruleSet">RuleSet to Serialize</param> /// <returns>Xml Formated representation of RuleSet</returns> private static string SerializeRuleSet(RuleSet ruleSet) { StringBuilder ruleDefinition = new StringBuilder(); if (ruleSet != null) { try { #region Serialize StringWriter stringWriter = new StringWriter(ruleDefinition, CultureInfo.InvariantCulture); XmlTextWriter writer = new XmlTextWriter(stringWriter); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); serializer.Serialize(writer, ruleSet); #endregion #region Cleanup writer.Flush(); writer.Close(); stringWriter.Flush(); stringWriter.Close(); #endregion } catch (Exception ex) { if (ruleSet != null) { MessageBox.Show(string.Format(CultureInfo.InvariantCulture, "Error serializing RuleSet: '{0}'. \r\n\n{1}", ruleSet.Name, ex.Message), "Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { MessageBox.Show(string.Format(CultureInfo.InvariantCulture, "Error serializing RuleSet. \r\n\n{0}", ex.Message), "Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } } else { if (ruleSet != null) { MessageBox.Show(String.Format(CultureInfo.InvariantCulture, "Error serializing RuleSet: '{0}'.", ruleSet.Name), "Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { MessageBox.Show("Error serializing RuleSet.", "Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } return(ruleDefinition.ToString()); }
internal static string SerializeRuleSet(object rules, DotNetPlatForm platForm) { StringBuilder ruleSet = new StringBuilder(); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); StringWriter stringWriter = new StringWriter(ruleSet, CultureInfo.InvariantCulture); XmlTextWriter writer = new XmlTextWriter(stringWriter); serializer.Serialize(writer, rules); writer.Flush(); writer.Close(); stringWriter.Flush(); stringWriter.Close(); return(ruleSet.ToString().UpdateStrongNameByPlatForm(platForm)); }