internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity)
{
Type contextType = null;
string className = String.Empty;
Activity rootActivity = null;
if (Helpers.IsActivityLocked(currentActivity))
{
rootActivity = Helpers.GetDeclaringActivity(currentActivity);
}
else
{
rootActivity = Helpers.GetRootActivity(currentActivity);
}
if (rootActivity != null)
{
className = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
if (!String.IsNullOrEmpty(className))
contextType = typeProvider.GetType(className, false);
if (contextType == null)
contextType = typeProvider.GetType(rootActivity.GetType().FullName);
// If all else fails (likely, we don't have a type provider), it's the root activity type.
if (contextType == null)
contextType = rootActivity.GetType();
}
return contextType;
}
public AzureQueueManager(Func<NamespaceManager> namespaceManager,
Func<MessagingFactory> messagingFactory,
AutoDeleteOnIdleSetting autoDeleteOnIdle,
DefaultMessageTimeToLiveSetting defaultMessageTimeToLive,
DefaultTimeoutSetting defaultTimeout,
EnableDeadLetteringOnMessageExpirationSetting enableDeadLetteringOnMessageExpiration,
GlobalPrefixSetting globalPrefix,
MaxDeliveryAttemptSetting maxDeliveryAttempts,
IPathFactory pathFactory,
IRetry retry,
ISqlFilterExpressionGenerator sqlFilterExpressionGenerator,
ITypeProvider typeProvider)
{
_namespaceManager = namespaceManager;
_messagingFactory = messagingFactory;
_maxDeliveryAttempts = maxDeliveryAttempts;
_retry = retry;
_typeProvider = typeProvider;
_defaultMessageTimeToLive = defaultMessageTimeToLive;
_autoDeleteOnIdle = autoDeleteOnIdle;
_defaultTimeout = defaultTimeout;
_enableDeadLetteringOnMessageExpiration = enableDeadLetteringOnMessageExpiration;
_globalPrefix = globalPrefix;
_sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
_pathFactory = pathFactory;
_knownTopics = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingTopics);
_knownSubscriptions = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingSubscriptions);
_knownQueues = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingQueues);
}
internal DoYourThingConfigurationConfigurator(ITypeProvider typeProvider, Action<IConfigurationSetting> registerAsSingleton)
{
_typeProvider = typeProvider;
_registerAsSingleton = registerAsSingleton;
_settingKeyConventions.AddRange(SettingKeyConventions.BuiltInConventions);
}
private RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType, Type[] typeArgs)
{
this.memberMapping = new Hashtable();
this.boundedTypes = new Hashtable(new TypeArrayComparer());
if (runtimeType == null)
{
throw new ArgumentNullException("runtimeType");
}
if (runtimeType.Assembly == null)
{
throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "runtimeType");
}
this.typeProvider = typeProvider;
this.runtimeType = runtimeType;
if (!this.IsGenericTypeDefinition)
{
throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "runtimeType");
}
this.typeArgs = new Type[typeArgs.Length];
for (int i = 0; i < typeArgs.Length; i++)
{
this.typeArgs[i] = typeArgs[i];
if (this.typeArgs[i] == null)
{
throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "typeArgs");
}
}
}
public IDependencyResolver Create(ITypeProvider typeProvider)
{
var kernel = new StandardKernel();
kernel.Components.Remove<IMissingBindingResolver, SelfBindingResolver>();
kernel.RegisterNimbus(typeProvider);
return kernel.Get<IDependencyResolver>();
}
private static Bus CreateBus(IWindsorContainer container, ITypeProvider typeProvider)
{
var configRetriever = container.Resolve<IGetEnvironmentConfiguration>();
try
{
// Get the Azure Service Bus connection string, app name, and unique name for this running instance
string connectionString = configRetriever.GetSetting(AzureServiceBusConnectionStringKey);
string appName = configRetriever.AppName;
string uniqueName = configRetriever.UniqueInstanceId;
Bus bus = new BusBuilder().Configure()
.WithConnectionString(connectionString)
.WithNames(appName, uniqueName)
.WithJsonSerializer()
.WithWindsorDefaults(container)
.WithTypesFrom(typeProvider)
.Build();
bus.Start();
return bus;
}
finally
{
container.Release(configRetriever);
}
}
private void Config(IProfileRegistry config, ITypeProvider typeProvider)
{
var largeMessageBodyTempPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Guid.NewGuid().ToString());
config.For<ILogger>()
.Use<ConsoleLogger>()
.Singleton();
config.For<ILargeMessageBodyStore>()
.Use(c => new FileSystemStorageBuilder().Configure()
.WithStorageDirectory(largeMessageBodyTempPath)
.WithLogger(c.GetInstance<ILogger>())
.Build())
.Singleton();
config.For<IBus>()
.Use(c => new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(@"Endpoint=sb://shouldnotexist.example.com/;SharedAccessKeyName=IntegrationTestHarness;SharedAccessKey=borkborkbork=")
.WithLargeMessageStorage(sc => sc.WithLargeMessageBodyStore(c.GetInstance<ILargeMessageBodyStore>())
.WithMaxSmallMessageSize(50 * 1024)
.WithMaxLargeMessageSize(1024 * 1024))
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(c.GetInstance<ILogger>())
.Build())
.Singleton();
}
public RuleValidation(Activity activity, ITypeProvider typeProvider, bool checkStaticType)
{
this.errors = new ValidationErrorCollection();
this.typesUsed = new Dictionary<string, Type>(0x10);
this.activeParentNodes = new Stack<CodeExpression>();
this.expressionInfoMap = new Dictionary<CodeExpression, RuleExpressionInfo>();
this.typeRefMap = new Dictionary<CodeTypeReference, Type>();
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (typeProvider == null)
{
throw new ArgumentNullException("typeProvider");
}
this.thisType = ConditionHelper.GetContextType(typeProvider, activity);
this.typeProvider = typeProvider;
this.checkStaticType = checkStaticType;
if (checkStaticType)
{
this.authorizedTypes = WorkflowCompilationContext.Current.GetAuthorizedTypes();
this.typesUsedAuthorized = new Dictionary<string, Type>();
this.typesUsedAuthorized.Add(voidTypeName, voidType);
}
}
public static ContainerBuilder RegisterNimbus(this ContainerBuilder builder, ITypeProvider typeProvider)
{
builder.RegisterTypes(typeProvider.AllHandlerTypes())
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder.RegisterType<AutofacMulticastEventHandlerFactory>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType<AutofacCompetingEventHandlerFactory>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType<AutofacCommandHandlerFactory>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType<AutofacRequestHandlerFactory>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType<AutofacMulticastRequestHandlerFactory>()
.AsImplementedInterfaces()
.SingleInstance();
return builder;
}
private void BuildContainer(ITypeProvider typeProvider)
{
if (_container != null) throw new InvalidOperationException("This factory is only supposed to be used to construct one test subject.");
_container = new WindsorContainer();
_container.RegisterNimbus(typeProvider);
}
public static ContainerBuilder RegisterNimbus(this ContainerBuilder builder, ITypeProvider typeProvider)
{
foreach (var handlerType in typeProvider.AllHandlerTypes())
{
var handlerInterfaceTypes = handlerType.GetInterfaces().Where(typeProvider.IsClosedGenericHandlerInterface);
foreach (var interfaceType in handlerInterfaceTypes)
{
builder.RegisterType(handlerType)
.Named(handlerType.FullName, interfaceType)
.InstancePerLifetimeScope();
}
}
builder.RegisterSource(new ContravariantRegistrationSource());
typeProvider.InterceptorTypes
.Do(t => builder.RegisterType(t)
.AsSelf()
.InstancePerLifetimeScope())
.Done();
builder.RegisterInstance(typeProvider)
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType<AutofacDependencyResolver>()
.As<IDependencyResolver>()
.SingleInstance();
return builder;
}
internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity)
{
Type type = null;
string str = string.Empty;
Activity declaringActivity = null;
if (System.Workflow.Activities.Common.Helpers.IsActivityLocked(currentActivity))
{
declaringActivity = System.Workflow.Activities.Common.Helpers.GetDeclaringActivity(currentActivity);
}
else
{
declaringActivity = System.Workflow.Activities.Common.Helpers.GetRootActivity(currentActivity);
}
if (declaringActivity != null)
{
str = declaringActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
if (!string.IsNullOrEmpty(str))
{
type = typeProvider.GetType(str, false);
}
if (type == null)
{
type = typeProvider.GetType(declaringActivity.GetType().FullName);
}
if (type == null)
{
type = declaringActivity.GetType();
}
}
return type;
}
public SettingsRegistrationService(IConfigInjectorLogger logger,
ITypeProvider typeProvider,
ISettingKeyConvention[] settingKeyConventions,
ISettingsReader settingsReader,
ISettingsOverrider settingsOverrider,
SettingValueConverter settingValueConverter,
bool allowEntriesInWebConfigThatDoNotHaveSettingsClasses,
Action<IConfigurationSetting> registerAsSingleton)
{
if (logger == null) throw new ArgumentNullException("logger");
if (typeProvider == null) throw new ArgumentNullException("typeProvider");
if (settingKeyConventions == null) throw new ArgumentNullException("settingKeyConventions");
if (settingsReader == null) throw new ArgumentNullException("settingsReader");
if (settingsOverrider == null) throw new ArgumentNullException("settingsOverrider");
if (settingValueConverter == null) throw new ArgumentNullException("settingValueConverter");
if (registerAsSingleton == null) throw new ArgumentNullException("registerAsSingleton");
_logger = logger;
_typeProvider = typeProvider;
_settingKeyConventions = settingKeyConventions;
_settingsReader = settingsReader;
_settingsOverrider = settingsOverrider;
_settingValueConverter = settingValueConverter;
_allowEntriesInWebConfigThatDoNotHaveSettingsClasses = allowEntriesInWebConfigThatDoNotHaveSettingsClasses;
_registerAsSingleton = registerAsSingleton;
}
public SourcesWindow(ITypeProvider typeProvider, ISourceNavigator sourceNavigator,
ISourcesProvider sourcesProvider
)
{
this.typeProvider = typeProvider;
this.sourceNavigator = sourceNavigator;
this.sourcesProvider = sourcesProvider;
}
public BaseDebuggerSessionTest()
{
var container = new CompositionContainer (new DirectoryCatalog (Environment.CurrentDirectory));
session = container.GetExportedValue<IDebuggerSession> ();
typeProvider = session.TypeProvider;
typeProvider.AddFilter (Path.GetDirectoryName (typeof (type1).Assembly.Location));
vm = session.VM as VirtualMachine;
}
private static IEnumerable<Type> SelectHandlerInterfaces(Type type, ITypeProvider typeProvider)
{
var handlerInterfaces = type
.GetInterfaces()
.Where(typeProvider.IsClosedGenericHandlerInterface)
.ToArray();
return handlerInterfaces;
}
public static IBindingRoot RegisterNimbus(this IBindingRoot kernel, ITypeProvider typeProvider)
{
kernel.Bind<IDependencyResolver>().To<NinjectDependencyResolver>().InSingletonScope();
kernel.Bind<ITypeProvider>().ToConstant(typeProvider).InSingletonScope();
BindAllHandlerInterfaces(kernel, typeProvider);
return kernel;
}
public MainWindow(
IDebuggerSession session,
ITypeProvider typeProvider,
DebuggerWindowManager windowManager
)
{
this.session = session;
this.typeProvider = typeProvider;
this.windowManager = windowManager;
}
public DebuggerSession(IVirtualMachine vm, ITypeProvider typeProvider,
IExecutionProvider executionProvider, IThreadProvider threadProvider,
IBreakpointProvider breakpointProvider)
{
this.typeProvider = typeProvider;
this.executionProvider = executionProvider;
this.threadProvider = threadProvider;
this.breakpointProvider = breakpointProvider;
this.vm = vm;
}
public static BusBuilderConfiguration WithDefaults(this BusBuilderConfiguration configuration, ITypeProvider typeProvider)
{
return configuration
.WithTypesFrom(typeProvider)
.WithDependencyResolver(new DependencyResolver(typeProvider))
.WithRouter(new DestinationPerMessageTypeRouter())
.WithCompressor(new NullCompressor())
.WithLogger(new NullLogger())
;
}
public RuleSetDialog(Type activityType, ITypeProvider typeProvider, RuleSet ruleSet)
{
if (activityType == null)
throw (new ArgumentNullException("activityType"));
InitializeDialog(ruleSet);
RuleValidation validation = new RuleValidation(activityType, typeProvider);
this.ruleParser = new Parser(validation);
}
protected static DbModel BuildModel(BoundedContextElement context, ITypeProvider typeProvider = null)
{
var builder = CreateBuilder(CreateMetadataProvider(MockSource(context)), typeProvider);
var contextId = context.Identity.Id;
var model = builder.Build(EffortProvider, contextId);
model.Dump();
return model;
}
public DebuggerSession(IVirtualMachine virtualMachine,
IExecutionProvider executionProvider, ITypeProvider typeProvider,
IThreadProvider threadProvider, IBreakpointProvider breakpointProvider)
{
VM = virtualMachine;
ExecutionProvider = executionProvider;
ThreadProvider = threadProvider;
TypeProvider = typeProvider;
BreakpointProvider = breakpointProvider;
}
private static void BindAllHandlerInterfaces(IBindingRoot kernel, ITypeProvider typeProvider)
{
typeProvider.AllHandlerTypes()
.ToList()
.ForEach(
handlerType =>
handlerType.GetInterfaces()
.Where(typeProvider.IsClosedGenericHandlerInterface)
.ToList()
.ForEach(interfaceType => kernel.Bind(interfaceType).To(handlerType).InTransientScope()));
}
public BreakpointMediator(ITypeProvider typeProvider, IBreakpointProvider breakpointProvider)
{
this.typeProvider = typeProvider;
this.breakpointProvider = breakpointProvider;
typeProvider.TypeLoaded += OnTypeLoaded;
typeProvider.TypeUnloaded += OnTypeUnloaded;
breakpointProvider.BreakpointAdded += OnBreakpointAdded;
breakpointProvider.BreakpointRemoved += OnBreakpointRemoved;
breakpointProvider.BreakpointEnabled += OnBreakpointEnabled;
breakpointProvider.BreakpointDisabled += OnBreakpointDisabled;
}
public DataContractSerializer(ITypeProvider typeProvider)
{
var dataContractResolver = new NimbusDataContractResolver(typeProvider);
_settings = new DataContractSerializerSettings
{
DataContractResolver = dataContractResolver,
SerializeReadOnlyTypes = true,
MaxItemsInObjectGraph = int.MaxValue,
KnownTypes = typeProvider.AllSerializableTypes()
};
}
public RuleConditionDialog(Type activityType, ITypeProvider typeProvider, CodeExpression expression)
{
if (activityType == null)
throw (new ArgumentNullException("activityType"));
InitializeComponent();
RuleValidation validation = new RuleValidation(activityType, typeProvider);
this.ruleParser = new Parser(validation);
InitializeDialog(expression);
}
internal RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType)
{
if (runtimeType == null)
throw new ArgumentNullException("runtimeType");
//we dont expect DesignTimeType to be passed to this class for wrapping purposes
if (runtimeType.Assembly == null)
throw new ArgumentException(SR.GetString(SR.Error_InvalidRuntimeType), "runtimeType");
this.typeProvider = typeProvider;
this.runtimeType = runtimeType;
}
public static IWindsorContainer RegisterNimbus(this IWindsorContainer container, ITypeProvider typeProvider)
{
container.Register(
Classes.From(typeProvider.AllHandlerTypes()).Pick().WithServiceAllInterfaces().LifestyleScoped(),
Component.For<IMulticastEventBroker>().ImplementedBy<WindsorMulticastEventBroker>().LifestyleSingleton(),
Component.For<ICompetingEventBroker>().ImplementedBy<WindsorCompetingEventBroker>().LifestyleSingleton(),
Component.For<ICommandBroker>().ImplementedBy<WindsorCommandBroker>().LifestyleSingleton(),
Component.For<IRequestBroker>().ImplementedBy<WindsorRequestBroker>().LifestyleSingleton(),
Component.For<IMulticastRequestBroker>().ImplementedBy<WindsorMulticastRequestBroker>().LifestyleSingleton()
);
return container;
}
public DebuggerSession(IVirtualMachine vm, ITypeProvider typeProvider,
IExecutionProvider executionProvider, IThreadProvider threadProvider,
IBreakpointProvider breakpointProvider)
{
this.typeProvider = typeProvider;
this.executionProvider = executionProvider;
this.threadProvider = threadProvider;
this.breakpointProvider = breakpointProvider;
this.vm = vm;
LogProvider.Debug += s => LogOnDebug (s);
LogProvider.Error += s => LogOnError (s);
}
public ControllerInitializer(IUnityContainer container, ITypeProvider <IHttpController> controllersProvider)
{
_container = container;
_controllersProvider = controllersProvider;
}
public WorkflowServiceHost(string workflowDefinitionPath, string ruleDefinitionPath, ITypeProvider typeProvider, params Uri[] baseAddress)
: this(new StreamedWorkflowDefinitionContext(workflowDefinitionPath, ruleDefinitionPath, typeProvider), baseAddress)
{
}
internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
{
if (!this.validateOnCreate)
{
return;
}
ValidationErrorCollection errors = new ValidationErrorCollection();
// For validation purposes, create a type provider in the type case if the
// host did not push one.
if (typeProvider == null)
{
typeProvider = WorkflowRuntime.CreateTypeProvider(root);
}
// Validate that we are purely XAML.
if (!isNewType)
{
if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, ErrorNumbers.Error_XomlWorkflowHasClassName));
}
Queue compositeActivities = new Queue();
compositeActivities.Enqueue(root);
while (compositeActivities.Count > 0)
{
Activity activity = compositeActivities.Dequeue() as Activity;
if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, ErrorNumbers.Error_XomlWorkflowHasCode));
}
CompositeActivity compositeActivity = activity as CompositeActivity;
if (compositeActivity != null)
{
foreach (Activity childActivity in compositeActivity.EnabledActivities)
{
compositeActivities.Enqueue(childActivity);
}
}
}
}
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
ValidationManager validationManager = new ValidationManager(serviceContainer);
using (WorkflowCompilationContext.CreateScope(validationManager))
{
foreach (Validator validator in validationManager.GetValidators(root.GetType()))
{
foreach (ValidationError error in validator.Validate(validationManager, root))
{
if (!error.UserData.Contains(typeof(Activity)))
{
error.UserData[typeof(Activity)] = root;
}
errors.Add(error);
}
}
}
if (errors.HasErrors)
{
throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
}
}
public SerializableTypeProvider(SerializationReflectionInspector inspector, ITypeProvider provider)
{
_inspector = inspector;
_types = new Dictionary <Type, SerializableType>();
Provider = provider;
}
public SerializableProperty(PropertyInfo @ref, SerializationMetadata metadata, ITypeProvider provider)
{
Ref = @ref;
Metadata = metadata;
Ext = provider.Extend(Ref.PropertyType);
}
private ValidationErrorCollection ValidateActivity(ValidationManager manager, ActivityBind bind, BindValidationContext validationContext)
{
ValidationError item = null;
ValidationErrorCollection errors = new ValidationErrorCollection();
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(Activity).Name }));
}
Activity request = Helpers.ParseActivityForBind(activity, bind.Name);
if (request == null)
{
item = bind.Name.StartsWith("/", StringComparison.Ordinal) ? new ValidationError(SR.GetString("Error_CannotResolveRelativeActivity", new object[] { bind.Name }), 0x128) : new ValidationError(SR.GetString("Error_CannotResolveActivity", new object[] { bind.Name }), 0x129);
item.PropertyName = base.GetFullPropertyName(manager) + ".Name";
}
else if ((bind.Path == null) || (bind.Path.Length == 0))
{
item = new ValidationError(SR.GetString("Error_PathNotSetForActivitySource"), 0x12b)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
if (!bind.Name.StartsWith("/", StringComparison.Ordinal) && !ValidationHelpers.IsActivitySourceInOrder(request, activity))
{
item = new ValidationError(SR.GetString("Error_BindActivityReference", new object[] { request.QualifiedName, activity.QualifiedName }), 0x12a, true)
{
PropertyName = base.GetFullPropertyName(manager) + ".Name"
};
}
IDesignerHost service = manager.GetService(typeof(IDesignerHost)) as IDesignerHost;
WorkflowDesignerLoader loader = manager.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if ((service != null) && (loader != null))
{
Type srcType = null;
if (service.RootComponent == request)
{
ITypeProvider provider = manager.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (provider == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
srcType = provider.GetType(service.RootComponentClassName);
}
else
{
request.GetType();
}
if (srcType != null)
{
MemberInfo memberInfo = MemberBind.GetMemberInfo(srcType, bind.Path);
if ((memberInfo == null) || ((memberInfo is PropertyInfo) && !(memberInfo as PropertyInfo).CanRead))
{
item = new ValidationError(SR.GetString("Error_InvalidMemberPath", new object[] { request.QualifiedName, bind.Path }), 300)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
Type memberType = null;
if (memberInfo is FieldInfo)
{
memberType = ((FieldInfo)memberInfo).FieldType;
}
else if (memberInfo is PropertyInfo)
{
memberType = ((PropertyInfo)memberInfo).PropertyType;
}
else if (memberInfo is EventInfo)
{
memberType = ((EventInfo)memberInfo).EventHandlerType;
}
if (!DoesTargetTypeMatch(validationContext.TargetType, memberType, validationContext.Access))
{
if (typeof(WorkflowParameterBinding).IsAssignableFrom(memberInfo.DeclaringType))
{
item = new ValidationError(SR.GetString("Warning_ParameterBinding", new object[] { bind.Path, request.QualifiedName, validationContext.TargetType.FullName }), 0x624, true)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
item = new ValidationError(SR.GetString("Error_TargetTypeMismatch", new object[] { memberInfo.Name, memberType.FullName, validationContext.TargetType.FullName }), 0x12d)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
}
}
}
}
else
{
MemberInfo info2 = MemberBind.GetMemberInfo(request.GetType(), bind.Path);
if ((info2 == null) || ((info2 is PropertyInfo) && !(info2 as PropertyInfo).CanRead))
{
item = new ValidationError(SR.GetString("Error_InvalidMemberPath", new object[] { request.QualifiedName, bind.Path }), 300)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
DependencyProperty dependencyProperty = DependencyProperty.FromName(info2.Name, info2.DeclaringType);
object obj2 = BindHelpers.ResolveActivityPath(request, bind.Path);
if (obj2 == null)
{
Type fromType = null;
if (info2 is FieldInfo)
{
fromType = ((FieldInfo)info2).FieldType;
}
else if (info2 is PropertyInfo)
{
fromType = ((PropertyInfo)info2).PropertyType;
}
else if (info2 is EventInfo)
{
fromType = ((EventInfo)info2).EventHandlerType;
}
if (!TypeProvider.IsAssignable(typeof(ActivityBind), fromType) && !DoesTargetTypeMatch(validationContext.TargetType, fromType, validationContext.Access))
{
if (typeof(WorkflowParameterBinding).IsAssignableFrom(info2.DeclaringType))
{
item = new ValidationError(SR.GetString("Warning_ParameterBinding", new object[] { bind.Path, request.QualifiedName, validationContext.TargetType.FullName }), 0x624, true)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
item = new ValidationError(SR.GetString("Error_TargetTypeMismatch", new object[] { info2.Name, fromType.FullName, validationContext.TargetType.FullName }), 0x12d)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
}
}
else if ((obj2 is ActivityBind) && (request.Parent != null))
{
ActivityBind bind2 = obj2 as ActivityBind;
bool flag = false;
BindRecursionContext context = manager.Context[typeof(BindRecursionContext)] as BindRecursionContext;
if (context == null)
{
context = new BindRecursionContext();
manager.Context.Push(context);
flag = true;
}
if (context.Contains(activity, bind))
{
item = new ValidationError(SR.GetString("Bind_ActivityDataSourceRecursionDetected"), 0x12f)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
else
{
context.Add(activity, bind);
PropertyValidationContext propertyValidationContext = null;
if (dependencyProperty != null)
{
propertyValidationContext = new PropertyValidationContext(request, dependencyProperty);
}
else
{
propertyValidationContext = new PropertyValidationContext(request, info2 as PropertyInfo, info2.Name);
}
errors.AddRange(ValidationHelpers.ValidateProperty(manager, request, bind2, propertyValidationContext, validationContext));
}
if (flag)
{
manager.Context.Pop();
}
}
else if ((validationContext.TargetType != null) && !DoesTargetTypeMatch(validationContext.TargetType, obj2.GetType(), validationContext.Access))
{
item = new ValidationError(SR.GetString("Error_TargetTypeMismatch", new object[] { info2.Name, obj2.GetType().FullName, validationContext.TargetType.FullName }), 0x12d)
{
PropertyName = base.GetFullPropertyName(manager) + ".Path"
};
}
}
}
}
if (item != null)
{
errors.Add(item);
}
return(errors);
}
public static Kontent WithTypeProvider(this Kontent module, ITypeProvider typeProvider)
{
module.ConfigureClientActions.Add(builder => builder.WithTypeProvider(typeProvider));
return(module);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
FaultHandlerActivity exceptionHandler = obj as FaultHandlerActivity;
if (exceptionHandler == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(FaultHandlerActivity).FullName), "obj");
}
// check parent must be exception handler
if (!(exceptionHandler.Parent is FaultHandlersActivity))
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_FaultHandlerActivityParentNotFaultHandlersActivity), ErrorNumbers.Error_FaultHandlerActivityParentNotFaultHandlersActivity));
}
// validate exception property
ITypeProvider typeProvider = manager.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
// Validate the required Type property
ValidationError error = null;
if (exceptionHandler.FaultType == null)
{
error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "FaultType"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "FaultType";
validationErrors.Add(error);
}
else if (!TypeProvider.IsAssignable(typeof(Exception), exceptionHandler.FaultType))
{
error = new ValidationError(SR.GetString(SR.Error_TypeTypeMismatch, new object[] { "FaultType", typeof(Exception).FullName }), ErrorNumbers.Error_TypeTypeMismatch);
error.PropertyName = "FaultType";
validationErrors.Add(error);
}
// Generate a warning for unrechable code, if the catch type is all and this is not the last exception handler.
/*if (exceptionHandler.FaultType == typeof(System.Exception) && exceptionHandler.Parent is FaultHandlersActivity && ((FaultHandlersActivity)exceptionHandler.Parent).Activities.IndexOf(exceptionHandler) != ((FaultHandlersActivity)exceptionHandler.Parent).Activities.Count - 1)
* {
* error = new ValidationError(SR.GetString(SR.Error_FaultHandlerActivityAllMustBeLast), ErrorNumbers.Error_FaultHandlerActivityAllMustBeLast, true);
* error.PropertyName = "FaultType";
* validationErrors.Add(error);
* }*/
if (exceptionHandler.EnabledActivities.Count == 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_EmptyBehaviourActivity, typeof(FaultHandlerActivity).FullName, exceptionHandler.QualifiedName), ErrorNumbers.Warning_EmptyBehaviourActivity, true));
}
// fault handler can not contain fault handlers, compensation handler and cancellation handler
if (((ISupportAlternateFlow)exceptionHandler).AlternateFlowActivities.Count > 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ModelingConstructsCanNotContainModelingConstructs), ErrorNumbers.Error_ModelingConstructsCanNotContainModelingConstructs));
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
RuleSetReference reference = obj as RuleSetReference;
if (reference == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleSetReference).FullName, "obj" }), "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
}
if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
}
if (!string.IsNullOrEmpty(reference.RuleSetName))
{
RuleDefinitions definitions = null;
RuleSetCollection ruleSets = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (definitions != null)
{
ruleSets = definitions.RuleSets;
}
if ((ruleSets == null) || !ruleSets.Contains(reference.RuleSetName))
{
ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, new object[] { reference.RuleSetName }), 0x576)
{
PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
};
errors.Add(error);
return(errors);
}
RuleSet set = ruleSets[reference.RuleSetName];
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
{
RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
set.Validate(validation);
ValidationErrorCollection errors2 = validation.Errors;
if (errors2.Count > 0)
{
string fullPropertyName = base.GetFullPropertyName(manager);
string str6 = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, new object[] { fullPropertyName });
int errorNumber = 0x577;
if (activity.Site != null)
{
foreach (ValidationError error2 in errors2)
{
ValidationError error3 = new ValidationError(error2.ErrorText, errorNumber)
{
PropertyName = fullPropertyName + ".RuleSet Definition"
};
errors.Add(error3);
}
return(errors);
}
foreach (ValidationError error4 in errors2)
{
ValidationError error5 = new ValidationError(str6 + " " + error4.ErrorText, errorNumber)
{
PropertyName = fullPropertyName
};
errors.Add(error5);
}
}
return(errors);
}
}
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, new object[] { "RuleSetReference" }), 0x578)
{
PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
};
errors.Add(item);
return(errors);
}
public ComponentParserStrategy(ITypeProvider typeProvider)
{
this.typeProvider = typeProvider;
}
public CommandResolver(ITypeProvider typeProvider, ICommandOptionConverter commandOptionConverter)
{
_typeProvider = typeProvider;
_commandOptionConverter = commandOptionConverter;
}
IOptionalClientSetup IOptionalClientSetup.WithTypeProvider(ITypeProvider typeProvider) => RegisterOrThrow(typeProvider, nameof(typeProvider));
public static BusBuilderConfiguration WithTypesFrom(this BusBuilderConfiguration configuration, ITypeProvider typeProvider)
{
configuration.TypeProvider = typeProvider;
return(configuration);
}
public ControllerParserStrategy(ITypeProvider typeProvider)
{
this.typeProvider = typeProvider;
}
public SwaggerSchemaDocumentFilter(ITypeProvider typeProvider,
IEnumerable <AbstractCustomAttributeHandler> abstractCustomAttributeHandlers)
{
_abstractCustomAttributeHandlers = abstractCustomAttributeHandlers;
_types = typeProvider.GetTypes(AppDomain.CurrentDomain.GetAssemblies());
}
private static void Add(ITypeProvider provider)
{
s_providersByName[provider.Name] = provider;
s_providersByType[provider.Type] = provider;
}
public BreakpointProvider(ITypeProvider typeProvider)
{
this.typeProvider = typeProvider;
typeProvider.TypeLoaded += OnTypeLoaded;
typeProvider.TypeUnloaded += OnTypeUnloaded;
}
public static IWindsorContainer RegisterNimbus(this IWindsorContainer container, ITypeProvider typeProvider)
{
container.Register(
Component.For <IDependencyResolver>().ImplementedBy <WindsorDependencyResolver>().LifestyleSingleton(),
Component.For <ITypeProvider>().Instance(typeProvider).LifestyleSingleton()
);
container.Register(
Classes.From(typeProvider.AllResolvableTypes())
.Where(t => true)
.LifestyleScoped()
);
return(container);
}
public static Type[] AllSerializableTypes(this ITypeProvider typeProvider)
{
return(new[] { typeof(NimbusMessage) }
.Union(typeProvider.AllMessageContractTypes())
.ToArray());
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
InvokeWorkflowActivity invokeWorkflow = obj as InvokeWorkflowActivity;
if (invokeWorkflow == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(InvokeWorkflowActivity).FullName), "obj");
}
if (invokeWorkflow.TargetWorkflow == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "TargetWorkflow"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type targetWorkflowType = invokeWorkflow.TargetWorkflow;
if (targetWorkflowType.Assembly == null && typeProvider.LocalAssembly != null)
{
Type workflowType = typeProvider.LocalAssembly.GetType(targetWorkflowType.FullName);
if (workflowType != null)
{
targetWorkflowType = workflowType;
}
}
if (!TypeProvider.IsAssignable(typeof(Activity), targetWorkflowType))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypeIsNotRootActivity, "TargetWorkflow"), ErrorNumbers.Error_TypeIsNotRootActivity);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
Activity rootActivity = null;
try
{
rootActivity = Activator.CreateInstance(targetWorkflowType) as Activity;
}
catch (Exception)
{
//
}
if (rootActivity == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_GetCalleeWorkflow, invokeWorkflow.TargetWorkflow), ErrorNumbers.Error_GetCalleeWorkflow);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
// Exec can't have activate receive.
Walker walker = new Walker();
walker.FoundActivity += delegate(Walker w, WalkerEventArgs args)
{
if ((args.CurrentActivity is WebServiceInputActivity && ((WebServiceInputActivity)args.CurrentActivity).IsActivating))
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ExecWithActivationReceive), ErrorNumbers.Error_ExecWithActivationReceive);
validationError.PropertyName = "Name";
validationErrors.Add(validationError);
args.Action = WalkerAction.Abort;
}
};
walker.Walk((Activity)rootActivity);
bool inAtomicScope = false;
Activity parentScope = invokeWorkflow.Parent;
while (parentScope != null)
{
if (parentScope is CompensatableTransactionScopeActivity || parentScope is TransactionScopeActivity)
{
inAtomicScope = true;
break;
}
parentScope = parentScope.Parent;
}
// Validate that if the workflow is transactional or being exec'd then it is not enclosed in an atomic scope.
if (inAtomicScope)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ExecInAtomicScope), ErrorNumbers.Error_ExecInAtomicScope);
validationErrors.Add(validationError);
}
foreach (WorkflowParameterBinding paramBinding in invokeWorkflow.ParameterBindings)
{
PropertyInfo propertyInfo = null;
propertyInfo = targetWorkflowType.GetProperty(paramBinding.ParameterName);
if (propertyInfo == null)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ParameterNotFound, paramBinding.ParameterName), ErrorNumbers.Error_ParameterNotFound);
if (InvokeWorkflowActivity.ReservedParameterNames.Contains(paramBinding.ParameterName))
{
validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWorkflow.GetType(), paramBinding.ParameterName);
}
validationErrors.Add(validationError);
continue;
}
Type parameterType = propertyInfo.PropertyType;
if (paramBinding.GetBinding(WorkflowParameterBinding.ValueProperty) != null)
{
ValidationErrorCollection memberErrors = ValidationHelpers.ValidateProperty(manager, invokeWorkflow, paramBinding.GetBinding(WorkflowParameterBinding.ValueProperty), new PropertyValidationContext(paramBinding, null, paramBinding.ParameterName), new BindValidationContext(parameterType, AccessTypes.Read));
if (memberErrors.Count != 0)
{
validationErrors.AddRange(memberErrors);
continue;
}
}
}
}
}
}
return(validationErrors);
}
public DynamicActivator(Type type, ITypeProvider provider, params Type[] parameterTypes)
: this(type.GetTypeInfo().GetConstructor(parameterTypes), provider)
{
}
public object GetArgumentValueAs(IServiceProvider serviceProvider, int argumentIndex, Type requestedType)
{
if (argumentIndex >= this.ArgumentValues.Count || argumentIndex < 0)
{
throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentIndex), "argumentIndex");
}
if (requestedType == null)
{
throw new ArgumentNullException("requestedType");
}
SupportedLanguages language = CompilerHelpers.GetSupportedLanguage(serviceProvider);
if (requestedType == typeof(string))
{
string returnValue = this.ArgumentValues[argumentIndex] as string;
// string values read by the code-dom parser are double escaped, so
// remove the 2nd escaping (we need to leave the escaping in at parse time)
// in case the attribute argument is never processed and emitted as
// the code snippet
if (returnValue != null)
{
try
{
returnValue = Regex.Unescape(returnValue);
}
catch
{
}
}
if (returnValue != null)
{
if (returnValue.EndsWith("\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(0, returnValue.Length - 1);
}
if (language == SupportedLanguages.CSharp && returnValue.StartsWith("@\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(2, returnValue.Length - 2);
}
else if (returnValue.StartsWith("\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(1, returnValue.Length - 1);
}
}
return(returnValue);
}
else if (requestedType.IsEnum)
{
string parseableValue = "";
bool firstValue = true;
foreach (string enumValue in (this.ArgumentValues[argumentIndex] as string).Split(new string[] { language == SupportedLanguages.CSharp ? "|" : "Or" }, StringSplitOptions.RemoveEmptyEntries))
{
if (!firstValue)
{
parseableValue += ",";
}
int valueSep = enumValue.LastIndexOf('.');
if (valueSep != -1)
{
parseableValue += enumValue.Substring(valueSep + 1);
}
else
{
parseableValue += enumValue;
}
firstValue = false;
}
return(Enum.Parse(requestedType, parseableValue));
}
else if (requestedType == typeof(bool))
{
return(System.Convert.ToBoolean(this.ArgumentValues[argumentIndex], CultureInfo.InvariantCulture));
}
else if (requestedType == typeof(Type))
{
string typeName = "";
if (this.ArgumentValues[argumentIndex] is CodeTypeOfExpression)
{
typeName = DesignTimeType.GetTypeNameFromCodeTypeReference((this.ArgumentValues[argumentIndex] as CodeTypeOfExpression).Type, null);
}
ITypeProvider typeProvider = serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider == null)
{
throw new Exception(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).ToString()));
}
Type returnType = ParseHelpers.ParseTypeName(typeProvider, language, typeName);
if (returnType == null)
{
// Try to parse the attribute value manually
string[] genericParamTypeNames = null;
string baseTypeName = string.Empty;
string elementDecorators = string.Empty;
if (ParseHelpers.ParseTypeName(typeName, language == SupportedLanguages.CSharp ? ParseHelpers.ParseTypeNameLanguage.CSharp : ParseHelpers.ParseTypeNameLanguage.VB, out baseTypeName, out genericParamTypeNames, out elementDecorators))
{
if (baseTypeName != null && genericParamTypeNames != null)
{
string parsedTypeName = baseTypeName + "`" + genericParamTypeNames.Length.ToString(CultureInfo.InvariantCulture) + "[";
foreach (string genericArg in genericParamTypeNames)
{
if (genericArg != genericParamTypeNames[0])
{
parsedTypeName += ",";
}
Type genericArgType = ParseHelpers.ParseTypeName(typeProvider, language, genericArg);
if (genericArgType != null)
{
parsedTypeName += "[" + genericArgType.FullName + "]";
}
else
{
parsedTypeName += "[" + genericArg + "]";
}
}
parsedTypeName += "]";
returnType = ParseHelpers.ParseTypeName(typeProvider, language, parsedTypeName);
}
}
}
return(returnType);
}
return(null);
}
public HandlerMapper(ITypeProvider typeProvider)
{
_typeProvider = typeProvider;
_handlerMap = new ThreadSafeLazy <IReadOnlyDictionary <Type, IReadOnlyDictionary <Type, Type[]> > >(Build);
}
public DynamicWriteTravellerBuilder(MethodBuilder builder, SerializableType target, TravellerContext context, ITypeProvider typeProvider)
{
_target = target;
_context = context;
_typeProvider = typeProvider;
_il = builder.IL;
_visitorVariable = new ILArgPointer(typeof(IWriteVisitor), 1);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
WebServiceInputActivity activity = obj as WebServiceInputActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(WebServiceInputActivity).FullName }), "obj");
}
if (!Helpers.IsActivityLocked(activity))
{
List <ParameterInfo> list;
List <ParameterInfo> list2;
if (activity.IsActivating)
{
if (WebServiceActivityHelpers.GetPreceedingActivities(activity).GetEnumerator().MoveNext())
{
ValidationError item = new ValidationError(SR.GetString("Error_ActivationActivityNotFirst"), 0x568)
{
PropertyName = "IsActivating"
};
errors.Add(item);
return(errors);
}
if (WebServiceActivityHelpers.IsInsideLoop(activity, null))
{
ValidationError error2 = new ValidationError(SR.GetString("Error_ActivationActivityInsideLoop"), 0x579)
{
PropertyName = "IsActivating"
};
errors.Add(error2);
return(errors);
}
}
else if (!WebServiceActivityHelpers.GetPreceedingActivities(activity, true).GetEnumerator().MoveNext())
{
ValidationError error3 = new ValidationError(SR.GetString("Error_WebServiceReceiveNotMarkedActivate"), 0x569)
{
PropertyName = "IsActivating"
};
errors.Add(error3);
return(errors);
}
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
Type interfaceType = null;
if (activity.InterfaceType != null)
{
interfaceType = service.GetType(activity.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
ValidationError error4 = new ValidationError(SR.GetString("Error_TypePropertyInvalid", new object[] { "InterfaceType" }), 0x116)
{
PropertyName = "InterfaceType"
};
errors.Add(error4);
return(errors);
}
if (!interfaceType.IsInterface)
{
ValidationError error5 = new ValidationError(SR.GetString("Error_InterfaceTypeNotInterface", new object[] { "InterfaceType" }), 0x570)
{
PropertyName = "InterfaceType"
};
errors.Add(error5);
return(errors);
}
if (string.IsNullOrEmpty(activity.MethodName))
{
errors.Add(ValidationError.GetNotSetValidationError("MethodName"));
return(errors);
}
MethodInfo interfaceMethod = Helpers.GetInterfaceMethod(interfaceType, activity.MethodName);
if (interfaceMethod == null)
{
ValidationError error6 = new ValidationError(SR.GetString("Error_MethodNotExists", new object[] { "MethodName", activity.MethodName }), 0x137)
{
PropertyName = "MethodName"
};
errors.Add(error6);
return(errors);
}
ValidationErrorCollection errors2 = WebServiceActivityHelpers.ValidateParameterTypes(interfaceMethod);
if (errors2.Count > 0)
{
foreach (ValidationError error7 in errors2)
{
error7.PropertyName = "MethodName";
}
errors.AddRange(errors2);
return(errors);
}
WebServiceActivityHelpers.GetParameterInfo(interfaceMethod, out list, out list2);
foreach (ParameterInfo info2 in list)
{
string name = info2.Name;
string parameterPropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity.GetType(), name);
Type type2 = info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType;
object binding = null;
if (activity.ParameterBindings.Contains(name))
{
if (activity.ParameterBindings[name].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
binding = activity.ParameterBindings[name].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
binding = activity.ParameterBindings[name].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!type2.IsPublic || !type2.IsSerializable)
{
ValidationError error8 = new ValidationError(SR.GetString("Error_TypeNotPublicSerializable", new object[] { name, type2.FullName }), 0x567)
{
PropertyName = parameterPropertyName
};
errors.Add(error8);
}
else if (!activity.ParameterBindings.Contains(name) || (binding == null))
{
ValidationError notSetValidationError = ValidationError.GetNotSetValidationError(name);
notSetValidationError.PropertyName = parameterPropertyName;
errors.Add(notSetValidationError);
}
else
{
AccessTypes read = AccessTypes.Read;
if (info2.ParameterType.IsByRef)
{
read |= AccessTypes.Write;
}
ValidationErrorCollection errors3 = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, binding, new PropertyValidationContext(activity.ParameterBindings[name], null, name), new BindValidationContext(info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType, read));
foreach (ValidationError error10 in errors3)
{
error10.PropertyName = parameterPropertyName;
}
errors.AddRange(errors3);
}
}
if (activity.ParameterBindings.Count > list.Count)
{
errors.Add(new ValidationError(SR.GetString("Warning_AdditionalBindingsFound"), 0x630, true));
}
bool flag = false;
foreach (Activity activity2 in WebServiceActivityHelpers.GetSucceedingActivities(activity))
{
if (((activity2 is WebServiceOutputActivity) && (((WebServiceOutputActivity)activity2).InputActivityName == activity.Name)) || ((activity2 is WebServiceFaultActivity) && (((WebServiceFaultActivity)activity2).InputActivityName == activity.Name)))
{
flag = true;
break;
}
}
if (((list2.Count > 0) || (interfaceMethod.ReturnType != typeof(void))) && !flag)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceResponseNotFound"), 0x55d));
}
}
return(errors);
}
public virtual Type GetType(string typeName)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
// try serialization manager
Type type = null;
if (this.designMode)
{
try
{
type = this.serializationManager.GetType(typeName);
}
catch
{
//Debug.Assert(false, "VSIP framwork threw exception on resolving type." + e.ToString());
}
}
if (type == null)
{
// If this is a design time type, we need to get it from our type provider.
ITypeProvider typeProvider = this.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider != null)
{
type = typeProvider.GetType(typeName, false);
}
}
if (type != null)
{
return(type);
}
// try loading the assembly directly
string assemblyName = string.Empty;
int commaIndex = typeName.IndexOf(",");
string fullyQualifiedTypeName = typeName;
if (commaIndex > 0)
{
assemblyName = typeName.Substring(commaIndex + 1);
typeName = typeName.Substring(0, commaIndex);
}
Assembly assembly = null;
assemblyName = assemblyName.Trim();
if (assemblyName.Length > 0)
{
if (assemblyName.IndexOf(',') >= 0)
{
try
{
assembly = Assembly.Load(assemblyName);
}
catch
{
//
}
}
typeName = typeName.Trim();
if (assembly != null)
{
type = assembly.GetType(typeName, false);
}
else
{
type = Type.GetType(fullyQualifiedTypeName, false);
}
}
return(type);
}
public WorkflowServiceHost(Stream workflowDefinition, Stream ruleDefinition, ITypeProvider typeProvider, params Uri[] baseAddress)
: this(new StreamedWorkflowDefinitionContext(workflowDefinition, ruleDefinition, typeProvider), baseAddress)
{
}
internal static void InternalCompileFromDomBatch(string[] files, string[] codeFiles, WorkflowCompilerParameters parameters, WorkflowCompilerResults results, string localAssemblyPath)
{
// Check all the library paths are valid.
foreach (string libraryPath in parameters.LibraryPaths)
{
if (!XomlCompilerHelper.CheckPathName(libraryPath))
{
WorkflowCompilerError libPathError =
new WorkflowCompilerError(string.Empty, 0, 0, ErrorNumbers.Error_LibraryPath.ToString(CultureInfo.InvariantCulture), string.Format(CultureInfo.CurrentCulture, SR.GetString(SR.LibraryPathIsInvalid), libraryPath));
libPathError.IsWarning = true;
results.Errors.Add(libPathError);
}
}
IList <AuthorizedType> authorizedTypes = null;
if (parameters.CheckTypes)
{
//If we dont find the list of authorized types then return.
authorizedTypes = WorkflowCompilationContext.Current.GetAuthorizedTypes();
if (authorizedTypes == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_ConfigFileMissingOrInvalid), ErrorNumbers.Error_ConfigFileMissingOrInvalid);
results.Errors.Add(CreateXomlCompilerError(error, parameters));
return;
}
}
ITypeProvider typeProvider = WorkflowCompilationContext.Current.ServiceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
ArrayList activities = new ArrayList();
using (PDBReader pdbReader = new PDBReader(localAssemblyPath))
{
// Validate all the compiled activities in the assembly.
foreach (Type type in typeProvider.LocalAssembly.GetTypes())
{
if (!TypeProvider.IsAssignable(typeof(Activity), type) || type.IsAbstract)
{
continue;
}
// Fetch file name.
string fileName = string.Empty;
WorkflowMarkupSourceAttribute[] sourceAttrs = (WorkflowMarkupSourceAttribute[])type.GetCustomAttributes(typeof(WorkflowMarkupSourceAttribute), false);
if (sourceAttrs != null && sourceAttrs.Length > 0)
{
fileName = sourceAttrs[0].FileName;
}
else
{
ConstructorInfo ctorMethod = type.GetConstructor(Type.EmptyTypes);
if (ctorMethod != null)
{
try
{
uint line = 0, column = 0;
pdbReader.GetSourceLocationForOffset((uint)ctorMethod.MetadataToken, 0, out fileName, out line, out column);
}
catch
{
// We don't want errors if the user has written their own custom
// activity and simply inherited the constructor
}
}
// In case of VB, if the ctor is autogenerated the PDB will not have symbol
// information. Use InitializeComponent method as the fallback. Bug 19085.
if (String.IsNullOrEmpty(fileName))
{
MethodInfo initializeComponent = type.GetMethod("InitializeComponent", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (initializeComponent != null)
{
try
{
uint line = 0, column = 0;
pdbReader.GetSourceLocationForOffset((uint)initializeComponent.MetadataToken, 0, out fileName, out line, out column);
if (!String.IsNullOrEmpty(fileName))
{
if (fileName.EndsWith(".designer.cs", StringComparison.OrdinalIgnoreCase))
{
fileName = fileName.Substring(0, fileName.Length - ".designer.cs".Length) + ".cs";
}
else if (fileName.EndsWith(".designer.vb", StringComparison.OrdinalIgnoreCase))
{
fileName = fileName.Substring(0, fileName.Length - ".designer.vb".Length) + ".vb";
}
}
}
catch
{
}
}
}
}
// Create the activity.
Activity activity = null;
try
{
try
{
Activity.ActivityType = type;
activity = Activator.CreateInstance(type) as Activity;
}
finally
{
Activity.ActivityType = null;
}
activity.UserData[UserDataKeys.CustomActivity] = false;
if (activity is CompositeActivity)
{
CompositeActivity compositeActivity = activity as CompositeActivity;
if (compositeActivity.CanModifyActivities)
{
results.Errors.Add(CreateXomlCompilerError(new ValidationError(SR.GetString(SR.Error_Missing_CanModifyProperties_False, activity.GetType().FullName), ErrorNumbers.Error_CustomActivityCantCreate), parameters));
}
}
if (sourceAttrs.Length > 0)
{
DesignerSerializationManager manager = new DesignerSerializationManager(WorkflowCompilationContext.Current.ServiceProvider);
Activity instance2 = null;
using (manager.CreateSession())
{
WorkflowMarkupSerializationManager xomlSerializationManager = new WorkflowMarkupSerializationManager(manager);
xomlSerializationManager.LocalAssembly = parameters.LocalAssembly;
using (XmlReader reader = XmlReader.Create((sourceAttrs[0].FileName)))
instance2 = new WorkflowMarkupSerializer().Deserialize(xomlSerializationManager, reader) as Activity;
}
if (instance2 is CompositeActivity)
{
ActivityMarkupSerializer.ReplaceChildActivities(activity as CompositeActivity, instance2 as CompositeActivity);
}
}
}
catch (TargetInvocationException tie)
{
// For TypeInitializationException, the message is available at the inner Exception
if (tie.InnerException is TypeInitializationException && tie.InnerException.InnerException != null)
{
results.Errors.Add(CreateXomlCompilerError(new ValidationError(SR.GetString(SR.Error_CustomActivityCantCreate, type.FullName, tie.InnerException.InnerException.ToString()), ErrorNumbers.Error_CustomActivityCantCreate), parameters));
}
else if (tie.InnerException.InnerException != null)
{
results.Errors.Add(CreateXomlCompilerError(new ValidationError(tie.InnerException.InnerException.ToString(), ErrorNumbers.Error_CustomActivityCantCreate), parameters));
}
else
{
results.Errors.Add(CreateXomlCompilerError(new ValidationError(SR.GetString(SR.Error_CustomActivityCantCreate, type.FullName, tie.InnerException.ToString()), ErrorNumbers.Error_CustomActivityCantCreate), parameters));
}
continue;
}
catch (Exception e)
{
results.Errors.Add(CreateXomlCompilerError(new ValidationError(SR.GetString(SR.Error_CustomActivityCantCreate, type.FullName, e.ToString()), ErrorNumbers.Error_CustomActivityCantCreate), parameters));
continue;
}
// Work around : another set of work arounds.
activity.SetValue(ActivityCodeDomSerializer.MarkupFileNameProperty, fileName);
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, type.FullName);
// Run the validators.
ValidateActivity(activity, parameters, results);
activities.Add(activity);
}
}
// Add all type load errors to compiler results.
foreach (KeyValuePair <object, Exception> entry in typeProvider.TypeLoadErrors)
{
WorkflowCompilerError compilerError = new WorkflowCompilerError(string.Empty, 0, 0, ErrorNumbers.Error_TypeLoad.ToString(CultureInfo.InvariantCulture), entry.Value.Message);
compilerError.IsWarning = true;
results.Errors.Add(compilerError);
}
results.CompiledUnit = WorkflowCompilerInternal.GenerateCodeFromFileBatch(files, parameters, results);
WorkflowCompilationContext context = WorkflowCompilationContext.Current;
if (context == null)
{
throw new Exception(SR.GetString(SR.Error_MissingCompilationContext));
}
// Fix standard namespaces and root namespace.
WorkflowMarkupSerializationHelpers.ReapplyRootNamespace(results.CompiledUnit.Namespaces, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language));
WorkflowMarkupSerializationHelpers.FixStandardNamespacesAndRootNamespace(results.CompiledUnit.Namespaces, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language));
if (!results.Errors.HasErrors)
{
// ask activities to generate code for themselves
CodeGenerationManager codeGenerationManager = new CodeGenerationManager(WorkflowCompilationContext.Current.ServiceProvider);
codeGenerationManager.Context.Push(results.CompiledUnit.Namespaces);
foreach (Activity activity in activities)
{
// Need to call code generators associated with the root activity.
if (activity.Parent == null)
{
foreach (System.Workflow.ComponentModel.Compiler.ActivityCodeGenerator codeGenerator in codeGenerationManager.GetCodeGenerators(activity.GetType()))
{
codeGenerator.GenerateCode(codeGenerationManager, activity);
}
}
}
// If only ccu needed then return.
if (!parameters.GenerateCodeCompileUnitOnly || parameters.CheckTypes)
{
// Convert all compile units to source files.
SupportedLanguages language = CompilerHelpers.GetSupportedLanguage(parameters.LanguageToUse);
CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language, parameters.CompilerVersion);
ArrayList ccus = new ArrayList((ICollection)parameters.UserCodeCompileUnits);
ccus.Add(results.CompiledUnit);
ArrayList sourceFilePaths = new ArrayList();
sourceFilePaths.AddRange(codeFiles);
sourceFilePaths.AddRange(XomlCompilerHelper.GenerateFiles(codeDomProvider, parameters, (CodeCompileUnit[])ccus.ToArray(typeof(CodeCompileUnit))));
// Finally give it to Code Compiler.
CompilerResults results2 = codeDomProvider.CompileAssemblyFromFile(parameters, (string[])sourceFilePaths.ToArray(typeof(string)));
results.AddCompilerErrorsFromCompilerResults(results2);
results.PathToAssembly = results2.PathToAssembly;
results.NativeCompilerReturnValue = results2.NativeCompilerReturnValue;
if (!results.Errors.HasErrors && parameters.CheckTypes)
{
foreach (string referenceType in MetaDataReader.GetTypeRefNames(results2.CompiledAssembly.Location))
{
bool authorized = false;
foreach (AuthorizedType authorizedType in authorizedTypes)
{
if (authorizedType.RegularExpression.IsMatch(referenceType))
{
authorized = (String.Compare(bool.TrueString, authorizedType.Authorized, StringComparison.OrdinalIgnoreCase) == 0);
if (!authorized)
{
break;
}
}
}
if (!authorized)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypeNotAuthorized, referenceType), ErrorNumbers.Error_TypeNotAuthorized);
results.Errors.Add(CreateXomlCompilerError(error, parameters));
}
}
}
//this line was throwing for the delay sign case. besides, copying PathToAssembly should do the same...
if (!results.Errors.HasErrors && !parameters.GenerateCodeCompileUnitOnly && parameters.GenerateInMemory &&
(string.IsNullOrEmpty(parameters.CompilerOptions) || !parameters.CompilerOptions.ToLower(CultureInfo.InvariantCulture).Contains("/delaysign")))
{
results.CompiledAssembly = results2.CompiledAssembly;
}
}
}
}
public static BusBuilderConfiguration WithDefaults(this BusBuilderConfiguration configuration, ITypeProvider typeProvider)
{
return(configuration
.WithTypesFrom(typeProvider)
.WithDependencyResolver(new DependencyResolver(typeProvider))
.WithRouter(new DestinationPerMessageTypeRouter())
.WithCompressor(new NullCompressor())
.WithLogger(new NullLogger())
);
}
public NimbusDataContractResolver(ITypeProvider typeProvider)
{
_typeToAssemblyLookup = typeProvider
.AllMessageContractTypes()
.ToDictionary(t => t.FullName, t => t.Assembly);
}
