internal override SqlExpression DATEPART(string partName, SqlExpression expr)
{
var args = new[] { expr };
return(new SqlFunctionCall(typeof(int), TypeProvider.From(typeof(int)),
partName, args, expr.SourceExpression));
}
//用来修正日期值为 0000:00:00 的情况
internal override SqlBinary Binary(SqlNodeType nodeType, SqlExpression left, SqlExpression right,
MethodInfo method, Type clrType, IProviderType sqlType)
{
var args = new[] { left, right };
if (left.NodeType != right.NodeType)
{
var m = args.Where(o => o.NodeType != SqlNodeType.Value).FirstOrDefault();
var n = args.OfType <SqlValue>().Select(o => o.Value).FirstOrDefault();
var type = m.ClrType.IsGenericType ? m.ClrType.GetGenericArguments()[0] : m.ClrType;
if (type == typeof(DateTime) && n == null)
{
if (nodeType == SqlNodeType.EQ)
{
var b1 = new SqlBinary(nodeType, clrType, sqlType, left, right, method);
var b2 = new SqlBinary(SqlNodeType.LT, clrType, sqlType, m,
ValueFromObject(DateTime.MinValue, m.SourceExpression));
return(new SqlBinary(SqlNodeType.Or, typeof(bool), TypeProvider.From(typeof(bool)), b1, b2));
}
if (nodeType == SqlNodeType.NE)
{
var b1 = new SqlBinary(nodeType, clrType, sqlType, left, right, method);
var b2 = new SqlBinary(SqlNodeType.GT, clrType, sqlType, m,
ValueFromObject(DateTime.MinValue, m.SourceExpression));
return(new SqlBinary(SqlNodeType.And, typeof(bool), TypeProvider.From(typeof(bool)), b1, b2));
}
}
}
return(base.Binary(nodeType, left, right, method, clrType, sqlType));
}
internal override SqlExpression String_Remove(SqlMethodCall mc)
{
var clrType = mc.Method.ReturnType;
Debug.Assert(clrType == typeof(string));
var startIndex = (int)((SqlValue)mc.Arguments[0]).Value;
var sourceObject = (mc.Object);
//var sourceString =
var arg1 = mc.Object;
var arg2 = ValueFromObject(startIndex, mc.SourceExpression);//Expression.Constant(startIndex));
var left = new SqlFunctionCall(typeof(string), TypeProvider.From(typeof(string)), "Left",
new[] { arg1, arg2 }, mc.SourceExpression);
if (mc.Arguments.Count == 2)
{
var count = (int)((SqlValue)mc.Arguments[1]).Value;
SqlExpression len1 = ValueFromObject(startIndex + count, mc.SourceExpression);
SqlExpression len2 = new SqlFunctionCall(typeof(int), TypeProvider.From(typeof(int)), "Length",
new[] { sourceObject }, mc.SourceExpression);
SqlExpression len = new SqlBinary(SqlNodeType.Sub, typeof(int), TypeProvider.From(typeof(int)),
len2, len1);
SqlExpression right = new SqlFunctionCall(typeof(string), TypeProvider.From(typeof(string)),
"Right", new[] { sourceObject, len }, mc.SourceExpression);
var result = new SqlBinary(SqlNodeType.Add, clrType, TypeProvider.From(clrType), left, right);
return(result);
}
Debug.Assert(mc.Arguments.Count == 1);
return(left);
}
internal override SqlExpression DateTime_DayOfWeek(SqlMember m, SqlExpression expr)
{
return(new SqlBinary(SqlNodeType.Sub, typeof(DayOfWeek), TypeProvider.From(typeof(int)),
FunctionCall(typeof(int), "DayOfWeek", new[] { expr }, expr.SourceExpression),
ValueFromObject(1, expr.SourceExpression)));
//return ConvertTo(typeof(DayOfWeek), Subtract(FunctionCall(typeof(int), "DayOfWeek", new[] { expr }, expr.SourceExpression), 1));
}
/// <summary>
/// Display the specified workflow type.
/// </summary>
/// <param name="root">Type of the workflow.</param>
public void DisplayType(Type root)
{
if (!typeof(Activity).IsAssignableFrom(root))
{
throw new ArgumentException("WorkflowViewPanel only supports displaying Activity objects.", "root");
}
this.surface = new DesignSurface();
this.host = this.surface.GetService(typeof(IDesignerHost)) as IDesignerHost;
TypeProvider provider = new TypeProvider(this.surface);
provider.AddAssembly(typeof(string).Assembly);
IServiceContainer container = this.surface.GetService(typeof(IServiceContainer)) as IServiceContainer;
container.AddService(typeof(ITypeProvider), provider);
if (this.host == null)
{
throw new ApplicationException("Cannot work with a null host.");
}
Queue <Activity> toProcess = new Queue <Activity>();
try
{
toProcess.Enqueue((Activity)root.InvokeMember(string.Empty, System.Reflection.BindingFlags.CreateInstance, null, null, null, CultureInfo.InvariantCulture));
}
catch (Exception exc)
{
MessageBox.Show("Could not load workflow type: " + exc.ToString());
this.surface = null;
this.host = null;
return;
}
// Do a non-recursive walk of the activity
// tree to display all activities.
while (toProcess.Count > 0)
{
Activity activity = toProcess.Dequeue();
host.Container.Add(activity, activity.QualifiedName);
if (activity is CompositeActivity)
{
foreach (Activity child in ((CompositeActivity)activity).Activities)
{
toProcess.Enqueue(child);
}
}
}
this.surface.BeginLoad(new WorkflowLoader());
workflowView = new MouseDisabledWorkflowView(host as IServiceProvider);
workflowView.Dock = DockStyle.Fill;
this.Controls.Add(workflowView);
}
public object Restore()
{
var type = TypeProvider.GetType(assemblyQualifiedName);
var ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new [] {
typeof(SerializationInfo),
typeof(StreamingContext)
}, null);
var serializationInfo = new SerializationInfo(type, new FormatterConverter());
serializationInfo.SetType(type);
for (var i = 0; i < keys.Length; i++)
{
serializationInfo.AddValue(keys[i], values[i]);
}
var streamingContext = new StreamingContext(StreamingContextStates.Clone);
var result = ctor.Invoke(new object[] { serializationInfo, streamingContext });
var onDeserialization = result as IDeserializationCallback;
if (onDeserialization != null)
{
onDeserialization.OnDeserialization(this);
}
return(result);
}
private static ITypeProvider GetTypeProvider(Options options)
{
var typeProvider = new TypeProvider()
{
IncludeInternalTypes = options.IncludeInternalTypes,
DllFilePaths = options.InputDirectories.ToArray(),
IncludeEnums = options.IncludeEnums,
IncludeClasses = options.IncludeClasses,
IncludeStructs = options.IncludeStructs,
Exclusions = ParseWildcards(options.Exclusions),
Inclusions = ParseWildcards(options.Inclusions),
};
return(typeProvider);
Regex[] ParseWildcards(IEnumerable <string> input)
{
if (input == null)
{
input = new string[0];
}
return(input.Select(item => Wildcard.ToRegex(item)).ToArray());
}
}
/// <summary>
/// Add a key point.
/// </summary>
/// <param name = "keyPoint">The key point to add.</param>
public override void Add(TValue keyPoint)
{
// Add keypoint, with it's relative position to the reference point as a key.
TMath relativePosition = TypeProvider.RelativePosition(keyPoint, _referenceKeyPoint);
_data.Add(relativePosition, keyPoint);
}
public void Execute()
{
var assemblyLevelSettings = new AssemblyLevelSettings(ModuleDefinition.Assembly);
if (assemblyLevelSettings.AssemblyConfigureAwait.HasValue)
{
LogInfo(
$"Detected assembly wide configuration (ConfigureAwait({assemblyLevelSettings.AssemblyConfigureAwait.Value}))");
}
var types = ModuleDefinition.GetTypes().ToList();
var typeProvider = new TypeProvider(AssemblyResolver);
var typeReferenceProvider = new TypeReferenceProvider(ModuleDefinition, typeProvider);
var asyncIlHelper = new AsyncIlHelper(typeProvider, typeReferenceProvider, ModuleDefinition);
var stopwach = Stopwatch.StartNew();
foreach (var typeDefinition in types)
{
ProcessType(assemblyLevelSettings, typeDefinition, asyncIlHelper);
}
LogInfo($"Needed {stopwach.ElapsedMilliseconds} ms to process {types.Count} types");
RemoveReference();
}
internal override SqlExpression String_Insert(SqlMethodCall mc)
{
var clrType = mc.Method.ReturnType;
var startIndex = (int)((SqlValue)mc.Arguments[0]).Value; //(int)((ConstantExpression)mc.Arguments[0]).Value;
var insertString = (string)((SqlValue)mc.Arguments[1]).Value; //(string)((ConstantExpression)mc.Arguments[1]).Value;
Debug.Assert(clrType == typeof(string));
Debug.Assert(startIndex >= 0);
var arg1 = mc.Object; //VisitExpression(mc.Object);
var arg2 = ValueFromObject(startIndex, mc.SourceExpression); //VisitExpression(Expression.Constant(startIndex));
var left = new SqlFunctionCall(clrType, TypeProvider.From(clrType), "LEFT",
new[] { arg1, arg2 }, mc.SourceExpression);
//return left;
var result = new SqlBinary(SqlNodeType.Add, typeof(string), TypeProvider.From(typeof(string)),
left, ValueFromObject(insertString, mc.SourceExpression));
var len = new SqlFunctionCall(typeof(int), TypeProvider.From(typeof(int)), "CHAR_LENGTH",
new[] { (mc.Object) }, mc.SourceExpression);
var binary = new SqlBinary(SqlNodeType.Sub, typeof(int), TypeProvider.From(typeof(int)), len, arg2);
var right = new SqlFunctionCall(typeof(string), TypeProvider.From(typeof(string)), "RIGHT",
new[] { arg1, binary }, mc.SourceExpression);
result = new SqlBinary(SqlNodeType.Add, typeof(string), TypeProvider.From(typeof(string)), result, right);
return(result);
}
object IDesignerSerializationProvider.GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
{
if (serializerType == typeof(WorkflowMarkupSerializer) && objectType != null)
{
if (TypeProvider.IsAssignable(typeof(ICollection <string>), objectType) && TypeProvider.IsAssignable(objectType, typeof(List <string>)) && !TypeProvider.IsAssignable(typeof(Array), objectType))
{
return(new StringCollectionMarkupSerializer());
}
else if (typeof(Color).IsAssignableFrom(objectType))
{
return(new ColorMarkupSerializer());
}
else if (typeof(Size).IsAssignableFrom(objectType))
{
return(new SizeMarkupSerializer());
}
else if (typeof(Point).IsAssignableFrom(objectType))
{
return(new PointMarkupSerializer());
}
else if (objectType == typeof(CodeTypeReference))
{
return(new CodeTypeReferenceSerializer());
}
}
return(null);
}
private void HandleMessage(string content, string queue)
{
try
{
var commandType = TypeProvider.GetTypeFromAnyReferencingAssembly(queue);
// deserialize event
var command = JsonConvert.DeserializeObject(content, commandType);
using (var scope = serviceProvider.CreateScope())
{
var commandBus =
scope.ServiceProvider.GetRequiredService <ICommandBus>();
// publish event to internal event bus
commandBus.Send(command as ICommand);
}
}
catch (Exception e)
{
_logger.LogInformation("Error consuming message: " + e.Message + e.StackTrace);
}
// we just print this message
_logger.LogInformation($"consumer received {content}");
}
bool ITypeFilterProvider.CanFilterType(Type type, bool throwOnError)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
bool flag = (TypeProvider.IsAssignable(typeof(Activity), type) && (type != typeof(Activity))) && !type.IsAbstract;
if (flag)
{
IDesignerHost service = this.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
if ((service != null) && (string.Compare(service.RootComponentClassName, type.FullName, StringComparison.Ordinal) == 0))
{
if (throwOnError)
{
throw new InvalidOperationException(SR.GetString("Error_CantInvokeSelf"));
}
flag = false;
}
}
if (throwOnError && !flag)
{
throw new Exception(SR.GetString("Error_TypeIsNotRootActivity", new object[] { "TargetWorkflow" }));
}
return(flag);
}
internal static TypeProvider CreateTypeProvider(Activity rootActivity)
{
TypeProvider typeProvider = new TypeProvider(null);
Type companionType = rootActivity.GetType();
typeProvider.SetLocalAssembly(companionType.Assembly);
typeProvider.AddAssembly(companionType.Assembly);
foreach (AssemblyName assemblyName in companionType.Assembly.GetReferencedAssemblies())
{
Assembly referencedAssembly = null;
try
{
referencedAssembly = Assembly.Load(assemblyName);
if (referencedAssembly != null)
{
typeProvider.AddAssembly(referencedAssembly);
}
}
catch
{
}
if (referencedAssembly == null && assemblyName.CodeBase != null)
{
typeProvider.AddAssemblyReference(assemblyName.CodeBase);
}
}
return(typeProvider);
}
public GenericClassImplementorFacade(ModuleDefinition module, TypeProvider provider, DataHelper dataHelper, AutomataEmbeddingHelper automataHelper)
{
this.module = module;
this.provider = provider;
this.dataHelper = dataHelper;
this.automataHelper = automataHelper;
}
private async Task ConsumeNextEvent(IConsumer <string, string> consumer, CancellationToken cancellationToken)
{
try
{
//lol ^_^ - remove this hack when this GH issue is solved: https://github.com/dotnet/extensions/issues/2149#issuecomment-518709751
await Task.Yield();
// wait for the upcoming message, consume it when arrives
var message = consumer.Consume(cancellationToken);
// get event type from name storred in message.Key
var eventType = TypeProvider.GetTypeFromAnyReferencingAssembly(message.Message.Key);
// deserialize event
var @event = JsonConvert.DeserializeObject(message.Message.Value, eventType);
using (var scope = serviceProvider.CreateScope())
{
var eventBus =
scope.ServiceProvider.GetRequiredService <IEventBus>();
// publish event to internal event bus
await eventBus.Publish(@event as IEvent, cancellationToken);
}
}
catch (Exception e)
{
logger.LogInformation("Error consuming message: " + e.Message + e.StackTrace);
}
}
/// <summary>
/// Save the file. We also refresh the type provider when we save the file
/// </summary>
/// <param name="filePath">The path of the file to save</param>
public void Save()
{
if (this.loader != null)
{
this.loader.Flush();
}
//Referesh the code compile unit every time the file is saved
TypeProvider typeProvider = (TypeProvider)GetService(typeof(ITypeProvider));
typeProvider.RemoveCodeCompileUnit(this.loader.XamlCodeCompileUnit);
this.loader.XamlCodeCompileUnit = new CodeCompileUnit();
this.loader.XamlCodeCompileUnit.Namespaces.Add(Helpers.GenerateCodeFromXomlDocument(Helpers.GetRootActivity(this.loader.Xoml), this, ref this.nameSpace, ref this.typeName));
typeProvider.AddCodeCompileUnit(this.loader.XamlCodeCompileUnit);
typeProvider.RemoveCodeCompileUnit(this.loader.CodeBesideCCU);
this.loader.CodeBesideCCU = new CodeCompileUnit();
this.loader.CodeBesideCCU.Namespaces.Add(Helpers.GenerateCodeBeside(Helpers.GetRootActivity(this.loader.Xoml), this));
typeProvider.AddCodeCompileUnit(this.loader.CodeBesideCCU);
if (UpdateCodeBeside != null)
{
UpdateCodeBeside(this, new EventArgs());
}
}
/// <summary>
/// 创建工作流运行时
/// </summary>
/// <param name="IsPer">是否使用持久化</param>
/// <returns></returns>
public static WorkflowRuntime CreateWorkFlowRuntime(bool IsPer)
{
try
{
WorkflowRuntime WfRuntime = new WorkflowRuntime();
if (IsPer)
{
ConnectionStringSettings defaultConnectionString = ConfigurationManager.ConnectionStrings["OracleConnection"];
WfRuntime.AddService(new AdoPersistenceService(defaultConnectionString, true, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(0)));
WfRuntime.AddService(new AdoTrackingService(defaultConnectionString));
WfRuntime.AddService(new AdoWorkBatchService());
}
FlowEvent ExternalEvent = new FlowEvent();
ExternalDataExchangeService objService = new ExternalDataExchangeService();
WfRuntime.AddService(objService);
objService.AddService(ExternalEvent);
ManualWorkflowSchedulerService scheduleService = new ManualWorkflowSchedulerService();
WfRuntime.AddService(scheduleService);
TypeProvider typeProvider = new TypeProvider(null);
WfRuntime.AddService(typeProvider);
WfRuntime.StartRuntime();
return(WfRuntime);
}
catch (Exception ex)
{
LogHelper.WriteLog("CreateWorkFlowRuntime异常信息 ：" + ex.ToString());
throw new Exception(ex.Message);
}
}
private static System.Type ValidateBaseType(string typeName, IServiceProvider serviceProvider)
{
if ((typeName == null) || (typeName.Length <= 0))
{
return(null);
}
ITypeProvider service = (ITypeProvider)serviceProvider.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new Exception(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
System.Type fromType = service.GetType(typeName);
if (fromType == null)
{
throw new Exception(SR.GetString("Error_TypeNotResolved", new object[] { typeName }));
}
IDesignerHost host = serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IDesignerHost).FullName }));
}
System.Type type = service.GetType(host.RootComponentClassName);
if (((fromType is DesignTimeType) && (type != null)) && (type.Assembly == fromType.Assembly))
{
throw new InvalidOperationException(SR.GetString("Error_CantUseCurrentProjectTypeAsBase"));
}
if (!TypeProvider.IsAssignable(typeof(Activity), fromType))
{
throw new InvalidOperationException(SR.GetString("Error_BaseTypeMustBeActivity"));
}
return(fromType);
}
public static CustomProperty CreateCustomProperty(IServiceProvider serviceProvider, string customPropertyName, PropertyDescriptor propertyDescriptor, object propertyOwner)
{
CustomProperty newCustomProperty = new CustomProperty(serviceProvider);
newCustomProperty.Name = customPropertyName;
if (TypeProvider.IsAssignable(typeof(ActivityBind), propertyDescriptor.PropertyType))
{
Type baseType = PropertyDescriptorUtils.GetBaseType(propertyDescriptor, propertyOwner, serviceProvider);
if (baseType == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_CantDeterminePropertyBaseType, propertyDescriptor.Name));
}
newCustomProperty.Type = baseType.FullName;
}
else
{
newCustomProperty.Type = propertyDescriptor.PropertyType.FullName;
}
if (propertyDescriptor is ActivityBindPropertyDescriptor)
{
DependencyProperty dependencyProperty = DependencyProperty.FromName(propertyDescriptor.Name, propertyDescriptor.ComponentType);
newCustomProperty.IsEvent = (dependencyProperty != null && dependencyProperty.IsEvent);
}
newCustomProperty.Category = propertyDescriptor.Category;
return(newCustomProperty);
}
public static IList <DependencyProperty> FromType(Type ownerType)
{
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
// Ensure static constructor of type has run
RuntimeHelpers.RunClassConstructor(ownerType.TypeHandle);
List <DependencyProperty> filteredProperties = new List <DependencyProperty>();
lock (((ICollection)DependencyProperty.dependencyProperties).SyncRoot)
{
foreach (DependencyProperty dependencyProperty in DependencyProperty.dependencyProperties.Values)
{
if (TypeProvider.IsSubclassOf(ownerType, dependencyProperty.ownerType) ||
ownerType == dependencyProperty.ownerType)
{
filteredProperties.Add(dependencyProperty);
}
}
}
return(filteredProperties.AsReadOnly());
}
/// <inheritdoc />
/// <exception cref="ArgumentException">Thrown when <paramref name="propertyTemplate" /> is null, empty string or whitespace</exception>
/// <exception cref="InvalidTemplateException"></exception>
/// <exception cref="MemberNotFoundException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public virtual object GetValue(string propertyTemplate)
{
if (string.IsNullOrWhiteSpace(propertyTemplate))
{
throw new ArgumentException(ArgumentHelper.EmptyStringParamMessage, nameof(propertyTemplate));
}
propertyTemplate = propertyTemplate.Trim();
MemberTemplateParts templateParts = ParseTemplate(propertyTemplate);
if (string.IsNullOrWhiteSpace(templateParts.MemberName))
{
throw new InvalidTemplateException(string.Format(Constants.InvalidTemplateMessage, propertyTemplate));
}
Type type = TypeProvider.GetType(templateParts.TypeName);
string[] props = templateParts.MemberName.Split(PropertiesSeparator);
MemberInfo member = GetFirstMember(props[0], type);
object firstMemberValue = GetFirstMemberValue(member, type);
if (props.Length == 1)
{
return(firstMemberValue ?? _reflectionHelper.GetNullValueAttributeValue(member));
}
return(_reflectionHelper.GetValueOfPropertiesChain(string.Join(PropertiesSeparator.ToString(), props.Skip(1)), firstMemberValue));
}
public static void LoadTypes()
{
VoucherIssuedEvent v = new VoucherIssuedEvent(Guid.NewGuid(), Guid.NewGuid(), DateTime.Now, "", "");
TransactionHasStartedEvent t = new TransactionHasStartedEvent(Guid.Parse("2AA2D43B-5E24-4327-8029-1135B20F35CE"), Guid.NewGuid(), Guid.NewGuid(),
DateTime.Now, "", "", "", "", null);
ReconciliationHasStartedEvent r =
new ReconciliationHasStartedEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), DateTime.Now);
EstateCreatedEvent e = new EstateCreatedEvent(Guid.NewGuid(), "");
MerchantCreatedEvent m = new MerchantCreatedEvent(Guid.NewGuid(), Guid.NewGuid(), "", DateTime.Now);
ContractCreatedEvent c = new ContractCreatedEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), "");
MerchantBalanceChangedEvent mb =
new MerchantBalanceChangedEvent(Guid.NewGuid(), Guid.NewGuid(), DateTime.Now, Guid.NewGuid(), Guid.NewGuid(), 0, 0, 0, "");
ImportLogCreatedEvent i = new ImportLogCreatedEvent(Guid.NewGuid(), Guid.NewGuid(), DateTime.MinValue);
FileCreatedEvent f = new FileCreatedEvent(Guid.NewGuid(),
Guid.NewGuid(),
Guid.NewGuid(),
Guid.NewGuid(),
Guid.NewGuid(),
Guid.NewGuid(),
String.Empty,
DateTime.MinValue);
SettlementCreatedForDateEvent s = new SettlementCreatedForDateEvent(Guid.NewGuid(), Guid.NewGuid(), DateTime.Now);
StatementCreatedEvent ms = new StatementCreatedEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), DateTime.Now);
TypeProvider.LoadDomainEventsTypeDynamically();
}
public StructStringKeyFormatterImplementor(ModuleDefinition module, TypeProvider provider, DataHelper dataHelper, AutomataEmbeddingHelper automataHelper)
{
this.module = module;
this.provider = provider;
this.dataHelper = dataHelper;
this.automataHelper = automataHelper;
}
private void addWorkflowBtn_Click(object sender, EventArgs e)
{
FindWorkflowForm form = new FindWorkflowForm();
form.BackendApplication = BackendApplication;
form.FrontendApplication = FrontendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
DataAccess.Domain.Workflow workflow = dialogService.GetWorkflowById(form.SelectedWorkflow.Id);
foreach (WorkflowSubworkflow subworkflow in Workflow.Subworkflows)
{
if (subworkflow.SubWorkflow.Id == workflow.Id)
{
MessageBox.Show("The selected Workflow is already present in the current Workflow.", "MetaManager");
return;
}
}
WorkflowSubworkflow workflowSubworkflow = new WorkflowSubworkflow();
workflowSubworkflow.SubWorkflow = workflow;
workflowSubworkflow.Workflow = Workflow;
Workflow.Subworkflows.Add(workflowSubworkflow);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[0], new ServiceMethod[0], new DataAccess.Domain.Workflow[] { workflow }).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
private void addServiceMethodBtn_Click(object sender, EventArgs e)
{
FindServiceMethodForm form = new FindServiceMethodForm();
form.FrontendApplication = FrontendApplication;
form.BackendApplication = BackendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
ServiceMethod serviceMethod = MetaManagerServices.GetApplicationService().GetServiceMethodMapsById(form.ServiceMethod.Id);
foreach (WorkflowServiceMethod wfServiceMethod in Workflow.ServiceMethods)
{
if (wfServiceMethod.ServiceMethod.Id == serviceMethod.Id)
{
MessageBox.Show("The selected Service Method is already present in the Workflow.", "MetaManager");
return;
}
}
WorkflowServiceMethod workflowServiceMethod = new WorkflowServiceMethod();
workflowServiceMethod.ServiceMethod = serviceMethod;
workflowServiceMethod.Workflow = Workflow;
Workflow.ServiceMethods.Add(workflowServiceMethod);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[0], new ServiceMethod[] { serviceMethod }, new DataAccess.Domain.Workflow[0]).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
public void TypeProviderReturnsClassInstance()
{
TypeProvider classProvider = new TypeProvider(typeof(Clazz));
object returnedResponse = classProvider.Apply(null, injector, null);
Assert.IsInstanceOf <Clazz>(returnedResponse);
}
public static CustomProperty CreateCustomProperty(IServiceProvider serviceProvider, string customPropertyName, PropertyDescriptor propertyDescriptor, object propertyOwner)
{
CustomProperty property = new CustomProperty(serviceProvider)
{
Name = customPropertyName
};
if (TypeProvider.IsAssignable(typeof(ActivityBind), propertyDescriptor.PropertyType))
{
System.Type type = PropertyDescriptorUtils.GetBaseType(propertyDescriptor, propertyOwner, serviceProvider);
if (type == null)
{
throw new InvalidOperationException(SR.GetString("Error_CantDeterminePropertyBaseType", new object[] { propertyDescriptor.Name }));
}
property.Type = type.FullName;
}
else
{
property.Type = propertyDescriptor.PropertyType.FullName;
}
if (propertyDescriptor is ActivityBindPropertyDescriptor)
{
DependencyProperty property2 = DependencyProperty.FromName(propertyDescriptor.Name, propertyDescriptor.ComponentType);
property.IsEvent = (property2 != null) && property2.IsEvent;
}
property.Category = propertyDescriptor.Category;
return(property);
}
public void TestClassLoader()
{
var classMetadataProvider = new ClassMetadataProvider();
var typeProvider = new TypeProvider(classMetadataProvider);
var classLoader = new ClassLoader(typeProvider, classMetadataProvider);
var intType = typeProvider.FindPrimitiveType(PrimitiveTypes.Int);
var classDef = new SharpJIT.Loader.Data.Class(
"Point",
new List <SharpJIT.Loader.Data.Field>()
{
new SharpJIT.Loader.Data.Field("x", intType.Name, SharpJIT.Core.Objects.AccessModifier.Public),
new SharpJIT.Loader.Data.Field("y", intType.Name, SharpJIT.Core.Objects.AccessModifier.Public)
});
classLoader.LoadClasses(new List <SharpJIT.Loader.Data.Class>()
{
classDef
});
var classMetadata = classMetadataProvider.GetMetadata(classDef.Name);
Assert.IsNotNull(classMetadata);
Assert.AreEqual(classDef.Name, classMetadata.Name);
var fields = classMetadata.Fields.ToList();
Assert.AreEqual(2, fields.Count);
Assert.AreEqual("x", fields[0].Name);
Assert.AreEqual(intType, fields[0].Type);
Assert.AreEqual("y", fields[1].Name);
Assert.AreEqual(intType, fields[1].Type);
}
/// <summary>
/// 创建工作流运行时
/// </summary>
/// <param name="IsPer">是否使用持久化</param>
/// <returns></returns>
public static WorkflowRuntime CreateWorkFlowRuntime(bool IsPer)
{
try
{
WorkflowRuntime WfRuntime = new WorkflowRuntime();
if (IsPer)
{
String connStringPersistence = ConfigurationManager.ConnectionStrings["SqlPersistenceConnection"].ConnectionString;//Data Source=172.30.50.110;Initial Catalog=WorkflowPersistence;Persist Security Info=True;User ID=sa;Password=fbaz2012;MultipleActiveResultSets=True";
SqlWorkflowPersistenceService persistence = new SqlWorkflowPersistenceService(connStringPersistence, true, new TimeSpan(0, 0, 30), new TimeSpan(0, 1, 0));
WfRuntime.AddService(persistence);
WfRuntime.WorkflowPersisted += new EventHandler <WorkflowEventArgs>(WfRuntime_WorkflowPersisted);
WfRuntime.ServicesExceptionNotHandled += new EventHandler <ServicesExceptionNotHandledEventArgs>(WfRuntime_ServicesExceptionNotHandled);
// ConnectionStringSettings defaultConnectionString = ConfigurationManager.ConnectionStrings["OracleConnection"];
// WfRuntime.AddService(new AdoPersistenceService(defaultConnectionString, true, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(0)));
// WfRuntime.AddService(new AdoTrackingService(defaultConnectionString));
// WfRuntime.AddService(new AdoWorkBatchService());
}
FlowEvent ExternalEvent = new FlowEvent();
ExternalDataExchangeService objService = new ExternalDataExchangeService();
WfRuntime.AddService(objService);
objService.AddService(ExternalEvent);
TypeProvider typeProvider = new TypeProvider(null);
WfRuntime.AddService(typeProvider);
WfRuntime.StartRuntime();
return(WfRuntime);
}
catch (Exception ex)
{
LogHelper.WriteLog("CreateWorkFlowRuntime异常信息 ：" + ex.ToString());
throw new Exception(ex.Message);
}
}
public Namespace(Identifier name, TypeProvider provideTypes, object providerHandle)
: base(NodeType.Namespace)
{
this.Name = name;
this.FullNameId = name;
if(name != null)
this.fullName = name.ToString();
this.ProvideTypes = provideTypes;
this.ProviderHandle = providerHandle;
}
