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