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