public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder, ProjectSettings projectSettings)
{
var container = new ObjectContainer();
RegisterDefaults(container);
var specFlowConfiguration = container.Resolve<ISpecFlowProjectConfigurationLoader>()
.LoadConfiguration(configurationHolder);
if (specFlowConfiguration.GeneratorConfiguration.CustomDependencies != null)
container.RegisterFromConfiguration(specFlowConfiguration.GeneratorConfiguration.CustomDependencies);
container.RegisterInstanceAs(specFlowConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.GeneratorConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.RuntimeConfiguration);
var generatorInfo = container.Resolve<IGeneratorInfoProvider>().GetGeneratorInfo();
container.RegisterInstanceAs(generatorInfo);
container.RegisterInstanceAs(projectSettings);
container.RegisterInstanceAs(container.Resolve<CodeDomHelper>(projectSettings.ProjectPlatformSettings.Language));
if (specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider != null)
container.RegisterInstanceAs(container.Resolve<IUnitTestGeneratorProvider>(specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider));
return container;
}
public virtual void RegisterDefaults(ObjectContainer container)
{
container.RegisterTypeAs<DefaultRuntimeConfigurationProvider, IRuntimeConfigurationProvider>();
container.RegisterTypeAs<TestRunnerManager, ITestRunnerManager>();
container.RegisterTypeAs<StepFormatter, IStepFormatter>();
container.RegisterTypeAs<TestTracer, ITestTracer>();
container.RegisterTypeAs<DefaultListener, ITraceListener>();
container.RegisterTypeAs<TraceListenerQueue, ITraceListenerQueue>();
container.RegisterTypeAs<ErrorProvider, IErrorProvider>();
container.RegisterTypeAs<RuntimeBindingSourceProcessor, IRuntimeBindingSourceProcessor>();
container.RegisterTypeAs<RuntimeBindingRegistryBuilder, IRuntimeBindingRegistryBuilder>();
container.RegisterTypeAs<BindingRegistry, IBindingRegistry>();
container.RegisterTypeAs<BindingFactory, IBindingFactory>();
container.RegisterTypeAs<StepDefinitionRegexCalculator, IStepDefinitionRegexCalculator>();
container.RegisterTypeAs<BindingInvoker, IBindingInvoker>();
container.RegisterTypeAs<StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
container.RegisterTypeAs<DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
container.RegisterTypeAs<StepTextAnalyzer, IStepTextAnalyzer>();
container.RegisterTypeAs<RuntimePluginLoader, IRuntimePluginLoader>();
container.RegisterTypeAs<BindingAssemblyLoader, IBindingAssemblyLoader>();
RegisterUnitTestProviders(container);
}
public void ObjectContainerSaveState(ObjectContainer o)
{
using (var stream = File.Create("x.ssa"))
{
stream.Write(_buffer, 0, 0);
}
}
public void TestObjectReferenceUpdate()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject { Name = "Test" };
var container = new ObjectContainer { Instance = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
var memberNode = containerNode.Children.First();
var instanceNode = memberNode.Content.Reference.AsObject.TargetNode;
// Update to a new instance
var newInstance = new TestObject { Name = "Test2" };
memberNode.Content.Update(newInstance);
Helper.TestMemberContentNode(containerNode, memberNode, container, newInstance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstance, false);
var newInstanceNode = nodeContainer.GetNode(newInstance);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstanceNode, newInstance);
Assert.AreNotEqual(instanceNode.Guid, newInstanceNode.Guid);
// Update to null
memberNode.Content.Update(null);
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
// Update back to the initial instance
memberNode.Content.Update(instance);
Helper.TestMemberContentNode(containerNode, memberNode, container, instance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instanceNode, instance);
}
public virtual void RegisterDefaults(ObjectContainer container)
{
container.RegisterTypeAs<DefaultRuntimeConfigurationProvider, IRuntimeConfigurationProvider>();
container.RegisterTypeAs<TestRunnerFactory, ITestRunnerFactory>();
container.RegisterTypeAs<TestRunner, ITestRunner>();
container.RegisterTypeAs<TestExecutionEngine, ITestExecutionEngine>();
container.RegisterTypeAs<StepDefinitionMatchService, IStepDefinitionMatchService>();
container.RegisterTypeAs<StepFormatter, IStepFormatter>();
container.RegisterTypeAs<TestTracer, ITestTracer>();
container.RegisterTypeAs<DefaultListener, ITraceListener>();
container.RegisterTypeAs<ErrorProvider, IErrorProvider>();
container.RegisterTypeAs<StepArgumentTypeConverter, IStepArgumentTypeConverter>();
container.RegisterTypeAs<BindingRegistry, IRuntimeBindingRegistryBuilder>();
container.RegisterTypeAs<BindingRegistry, IBindingRegistry>();
container.RegisterTypeAs<BindingFactory, IBindingFactory>();
container.RegisterTypeAs<StepDefinitionRegexCalculator, IStepDefinitionRegexCalculator>();
container.RegisterTypeAs<BindingInvoker, IBindingInvoker>();
container.RegisterTypeAs<ContextManager, IContextManager>();
container.RegisterTypeAs<StepDefinitionSkeletonProviderCS, IStepDefinitionSkeletonProvider>(ProgrammingLanguage.CSharp.ToString());
container.RegisterTypeAs<StepDefinitionSkeletonProviderVB, IStepDefinitionSkeletonProvider>(ProgrammingLanguage.VB.ToString());
container.RegisterTypeAs<RuntimePluginLoader, IRuntimePluginLoader>();
container.RegisterTypeAs<BindingAssemblyLoader, IBindingAssemblyLoader>();
RegisterUnitTestProviders(container);
}
public void ContainerShouldThrowExceptionWhenDisposed()
{
var container = new ObjectContainer();
container.Dispose();
container.Resolve<IObjectContainer>();
}
/* CONSTRUCTOR */
public ObjectInfo (ObjectContainer container)
{
Container = container;
Depends = container.Depends.ToArray ();
SystemType = container.SystemType;
RefId = container.RefId;
}
public IObjectContainer CreateTestRunnerContainer(IObjectContainer globalContainer)
{
var testRunnerContainer = new ObjectContainer(globalContainer);
defaultDependencyProvider.RegisterTestRunnerDefaults(testRunnerContainer);
return testRunnerContainer;
}
public void ShouldNotRegisterInvalidTypeMapping()
{
// given
var container = new ObjectContainer();
// then
Assert.Catch<InvalidOperationException>(() => container.RegisterTypeAs(typeof(SimpleClassExtendingGenericInterface), typeof(IGenericInterface<>)));
}
public override void Init()
{
base.Init();
_box = (BeerBox) Container["beer.box"];
_objContainer = (ObjectContainer)Container[typeof(ObjectContainer)];
}
public void Serialize(ObjectContainer o)
{
var formatter = new BinaryFormatter();
using (var stream = File.Create("x.dat"))
{
formatter.Serialize(stream, o);
}
}
private static void RegisterDefaults(ObjectContainer container)
{
container.RegisterTypeAs<SpecFlowProjectConfigurationLoader, ISpecFlowProjectConfigurationLoader>();
container.RegisterTypeAs<InProcGeneratorInfoProvider, IGeneratorInfoProvider>();
container.RegisterTypeAs<TestGenerator, ITestGenerator>();
container.RegisterTypeAs<TestHeaderWriter, ITestHeaderWriter>();
container.RegisterTypeAs<TestUpToDateChecker, ITestUpToDateChecker>();
}
public void SetUp()
{
mockTestRunner = MockRepository.GenerateMock<ITestRunner>();
var container = new ObjectContainer();
container.RegisterInstanceAs(mockTestRunner);
steps = new StepsTestableHelper();
((IContainerDependentObject)steps).SetObjectContainer(container);
}
private static string DisplayValue(Tk5FieldInfoEx field, ObjectContainer container, bool showHint)
{
TkDebug.AssertArgumentNull(field, "field", null);
//if (field.Upload != null)
// return DisplayUpload(field, row);
object receiver = container.MainObject;
string displayValue = string.Empty;
string value = string.Empty;
try
{
value = receiver.MemberValue(field.NickName).ConvertToString();
if (field.Decoder == null || field.Decoder.Type == DecoderType.None)
displayValue = FormatNumber(field, field.NickName, receiver);
else
displayValue = container.Decoder.GetNameString(field.NickName);
}
catch
{
displayValue = value;
}
if (showHint)
{
if (!string.IsNullOrEmpty(field.Hint))
displayValue += " " + field.Hint;
}
if (field.ListDetail != null && field.ListDetail.Link != null)
{
var link = field.ListDetail.Link;
string linkUrl = string.Empty;
string target = string.Empty;
switch (link.RefType)
{
case LinkRefType.Href:
linkUrl = HtmlUtil.ParseLinkUrl(receiver, link.Content);
linkUrl = WebUtil.ResolveUrl(linkUrl);
if (!string.IsNullOrEmpty(link.Base))
linkUrl = UriUtil.CombineUri(link.Base, linkUrl).ToString();
if (!string.IsNullOrEmpty(link.Target))
target = string.Format(ObjectUtil.SysCulture, " target=\"{0}\"", link.Target);
break;
case LinkRefType.Http:
if (!value.StartsWith("http", StringComparison.OrdinalIgnoreCase))
linkUrl = "http://";
linkUrl += value;
target = " target=\"_blank\"";
break;
case LinkRefType.Email:
linkUrl = "mailto:" + value;
target = " target=\"_blank\"";
break;
}
return string.Format(ObjectUtil.SysCulture, "<a href=\"{0}\"{1}>{2}</a>",
StringUtil.EscapeHtmlAttribute(linkUrl), target, StringUtil.EscapeHtml(displayValue));
}
return displayValue;
}
private static IGeneratorPlugin[] LoadPlugins(ObjectContainer container, IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder)
{
var plugins = container.Resolve<IDictionary<string, IGeneratorPlugin>>().Values.AsEnumerable();
var pluginLoader = container.Resolve<IGeneratorPluginLoader>();
plugins = plugins.Concat(configurationProvider.GetPlugins(configurationHolder).Where(pd => (pd.Type & PluginType.Generator) != 0).Select(pd => LoadPlugin(pluginLoader, pd)));
return plugins.ToArray();
}
partial void RegisterUnitTestProviders(ObjectContainer container)
{
container.RegisterTypeAs<NUnitRuntimeProvider, IUnitTestRuntimeProvider>("nunit");
container.RegisterTypeAs<MbUnitRuntimeProvider, IUnitTestRuntimeProvider>("mbunit");
container.RegisterTypeAs<MbUnit3RuntimeProvider, IUnitTestRuntimeProvider>("mbunit.3");
container.RegisterTypeAs<XUnitRuntimeProvider, IUnitTestRuntimeProvider>("xunit");
container.RegisterTypeAs<MsTestRuntimeProvider, IUnitTestRuntimeProvider>("mstest");
container.RegisterTypeAs<MsTest2010RuntimeProvider, IUnitTestRuntimeProvider>("mstest.2010");
}
public TransformManager(GameEditor edit)
{
ma = new MoveArrows();
rc = new RotateCircles();
editor = edit;
currentState = TransformManagerState.select;
activeObject = new ObjectContainer();
GameEngine.renderController.setSelect();
}
public void ShouldNotBeAbleToResolveStructsWithoutCtor()
{
// given
var container = new ObjectContainer();
// when
container.Resolve<MyStructWithoutCtor>();
}
public void NamedRegistrationShouldNotInflucenceNormalRegistrations()
{
var container = new ObjectContainer();
container.RegisterTypeAs<VerySimpleClass, IInterface1>("a_name");
// when
container.Resolve<IInterface1>();
}
public void CreateSingletonObject()
{
ObjectContainer locator = new ObjectContainer();
locator.DeclareSingleton(typeof(object));
var result = locator.Create<object>();
Assert.IsAssignableFrom<object>(result);
var result2 = locator.Create<object>();
Assert.AreSame(result, result2);
}
public void RegisterSingletonObject()
{
ObjectContainer locator = new ObjectContainer();
locator.RegisterSingleton<object>(c => { return new object(); });
var result = locator.Create<object>();
Assert.IsAssignableFrom<object>(result);
var result2 = locator.Create<object>();
Assert.AreSame(result, result2);
}
protected virtual IRuntimePlugin[] LoadPlugins(IRuntimeConfigurationProvider configurationProvider, ObjectContainer container)
{
var plugins = container.Resolve<IDictionary<string, IRuntimePlugin>>().Values.AsEnumerable();
var pluginLoader = container.Resolve<IRuntimePluginLoader>();
plugins = plugins.Concat(configurationProvider.GetPlugins().Where(pd => (pd.Type & PluginType.Runtime) != 0).Select(pd => LoadPlugin(pluginLoader, pd)));
return plugins.ToArray();
}
public virtual void RegisterDefaults(ObjectContainer container)
{
container.RegisterTypeAs<GeneratorConfigurationProvider, IGeneratorConfigurationProvider>();
container.RegisterTypeAs<InProcGeneratorInfoProvider, IGeneratorInfoProvider>();
container.RegisterTypeAs<TestGenerator, ITestGenerator>();
container.RegisterTypeAs<TestHeaderWriter, ITestHeaderWriter>();
container.RegisterTypeAs<TestUpToDateChecker, ITestUpToDateChecker>();
container.RegisterTypeAs<GeneratorPluginLoader, IGeneratorPluginLoader>();
container.RegisterTypeAs<UnitTestFeatureGenerator, UnitTestFeatureGenerator>();
container.RegisterTypeAs<FeatureGeneratorRegistry, IFeatureGeneratorRegistry>();
container.RegisterTypeAs<UnitTestFeatureGeneratorProvider, IFeatureGeneratorProvider>("default");
container.RegisterTypeAs<TagFilterMatcher, ITagFilterMatcher>();
container.RegisterTypeAs<StepDefinitionMatchService, IStepDefinitionMatchService>();
container.RegisterTypeAs<DecoratorRegistry, IDecoratorRegistry>();
container.RegisterTypeAs<IgnoreDecorator, ITestClassTagDecorator>("ignore");
container.RegisterTypeAs<IgnoreDecorator, ITestMethodTagDecorator>("ignore");
container.RegisterTypeAs<DefaultRuntimeConfigurationProvider, IRuntimeConfigurationProvider>();
// container.RegisterTypeAs<TestRunnerFactory, ITestRunnerFactory>();
container.RegisterTypeAs<TestRunner, ITestRunner>();
container.RegisterTypeAs<TestExecutionEngine, ITestExecutionEngine>();
container.RegisterTypeAs<StepDefinitionMatchService, IStepDefinitionMatchService>();
container.RegisterTypeAs<StepFormatter, IStepFormatter>();
container.RegisterTypeAs<TestTracer, ITestTracer>();
container.RegisterTypeAs<NUnitRuntimeProvider, IUnitTestRuntimeProvider>();
container.RegisterTypeAs<DefaultListener, ITraceListener>();
container.RegisterTypeAs<ErrorProvider, IErrorProvider>();
container.RegisterTypeAs<StepArgumentTypeConverter, IStepArgumentTypeConverter>();
container.RegisterTypeAs<RuntimeBindingSourceProcessor, IRuntimeBindingSourceProcessor>();
container.RegisterTypeAs<RuntimeBindingRegistryBuilder, IRuntimeBindingRegistryBuilder>();
container.RegisterTypeAs<BindingRegistry, IBindingRegistry>();
container.RegisterTypeAs<BindingFactory, IBindingFactory>();
container.RegisterTypeAs<StepDefinitionRegexCalculator, IStepDefinitionRegexCalculator>();
container.RegisterTypeAs<BindingInvoker, IBindingInvoker>();
container.RegisterTypeAs<ContextManager, IContextManager>();
container.RegisterTypeAs<StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
container.RegisterTypeAs<DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
container.RegisterTypeAs<StepTextAnalyzer, IStepTextAnalyzer>();
container.RegisterTypeAs<RuntimePluginLoader, IRuntimePluginLoader>();
container.RegisterTypeAs<BindingAssemblyLoader, IBindingAssemblyLoader>();
container.RegisterInstanceAs(GenerationTargetLanguage.CreateCodeDomHelper(GenerationTargetLanguage.CSharp), GenerationTargetLanguage.CSharp);
container.RegisterInstanceAs(GenerationTargetLanguage.CreateCodeDomHelper(GenerationTargetLanguage.VB), GenerationTargetLanguage.VB);
RegisterUnitTestGeneratorProviders(container);
}
public void Setup()
{
// given
container = new ObjectContainer();
container.RegisterTypeAs<IInterface1>(typeof(ConstructorTrackingClass));
calledConstructors = new List<ConstructorTrackingClass>();
constructorTrackingClassOnConstructorCalled = ctc => calledConstructors.Add(ctc);
ConstructorTrackingClass.ConstructorCalled += constructorTrackingClassOnConstructorCalled;
}
public void RegisterDependencies(ObjectContainer container)
{
container.RegisterTypeAs<NUnitTestGeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("nunit");
container.RegisterTypeAs<MbUnitTestGeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("mbunit");
container.RegisterTypeAs<MbUnit3TestGeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("mbunit.3");
container.RegisterTypeAs<XUnitTestGeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("xunit");
container.RegisterTypeAs<MsTestGeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("mstest.2008");
container.RegisterTypeAs<MsTest2010GeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("mstest.2010");
container.RegisterTypeAs<MsTest2010GeneratorProvider, TechTalk.SpecFlow.Generator.UnitTestProvider.IUnitTestGeneratorProvider>("mstest");
}
public void ShouldNotBeAbleToResolveStringTypes()
{
// given
var container = new ObjectContainer();
// when
container.Resolve<string>();
}
public void ShouldNotBeAbleToResolvePrimitiveTypes()
{
// given
var container = new ObjectContainer();
// when
container.Resolve<int>();
}
public void TestNullObjectReference()
{
var nodeContainer = new NodeContainer();
var container = new ObjectContainer { Instance = null };
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectContentNode(containerNode, container, 1);
var memberNode = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
}
protected PivotAction(ObjectContainer @object)
{
if (@object != null)
{
operatingObject = @object;
StartTransform = new Matrix[@object.Length];
for (int i = 0; i < @object.Length; i++)
StartTransform[i] = @object[i].transform;
}
}
public void ConfigureModulesWith2Modules()
{
ApplicationConfiguration config = new ApplicationConfiguration();
config.ModulesConfiguration.Modules.Add(new ModuleDefinition() { Type = GetTypeFullname("Module1") });
config.ModulesConfiguration.Modules.Add(new ModuleDefinition() { Type = GetTypeFullname("Module2") });
ObjectContainer container = new ObjectContainer();
ConfigManager.ConfigureModules(container, config);
Assert.AreEqual(2, container.AllObjects.Length);
}
private static IRuntimePlugin[] LoadPlugins(IRuntimeConfigurationProvider configurationProvider, ObjectContainer container)
{
var plugins = container.Resolve <IDictionary <string, IRuntimePlugin> >().Values.AsEnumerable();
var pluginLoader = container.Resolve <IRuntimePluginLoader>();
plugins = plugins.Concat(configurationProvider.GetPlugins().Where(pd => (pd.Type & PluginType.Runtime) != 0).Select(pd => LoadPlugin(pluginLoader, pd)));
return(plugins.ToArray());
}
/// <summary>
/// 初始化<c> AppInitEventArgs </ c>类的新实例.
/// </summary>
/// <param name="configSource">用于配置应用程序的<see cref ="IConfigSource"/>实例.</param>
/// <param name="objectContainer">应用程序注册或解析对象依赖关系的<see cref ="IObjectContainer"/>实例.</param>
public AppInitEventArgs(IConfigSource configSource, ObjectContainer objectContainer)
{
ConfigSource = configSource;
ObjectContainer = objectContainer;
}
public static IUnitOfWork StartUnitOfWork()
{
_currentUnitOfWork = ObjectContainer.Resolve <IUnitOfWork>();
return(_currentUnitOfWork);
}
public async Task <ActionResult> Grab()
{
try
{
#region 参数验证
var validateResult = ParamsValidateMethod();
if (validateResult != null)
{
return(validateResult);
}
string orderId = Request["OrderId"];
long operSoufunId = long.Parse(Request["OperSoufunId"]);
long ownerSoufunId = long.Parse(Request["OwnerSoufunId"]);
string operSoufunName = Request["OperSoufunName"] ?? "";
#endregion
#region 数据验证
string errMsg = string.Empty;
EBS.Interface.Model.Admin_UserInfo auiModel = null;
if (!new ParamValidateHelper().AllParamsValidate(out errMsg, out auiModel, orderId, operSoufunId, operSoufunName, ownerSoufunId))
{
throw new Exception(errMsg);
}
var asaModel = EBS.Interface.Data.DBOper.Admin_SubAuth.Get("IsDel=0 and CONSTCODE=@code", "CreateTime desc", new object[] { "ADD_CUSTOMER" }, false);
if (asaModel == null || asaModel.ID <= 0)
{
throw new ArgumentException(string.Format("CONSTCODE为：[{0}]的Admin_SubAuth表信息为空！", "ADD_CUSTOMER"));
}
if (asaModel.OrderService <= 0)
{
throw new Exception("非订单特定服务，无需操作！");
}
if (auiModel.FunctionId <= 0)
{
throw new Exception("用户未分配职能！");
}
var afiModel = EBS.Interface.Data.DBOper.Admin_FunctionInfo.Get("IsDel=0 and Id=@functionId", "CreateTime desc", new object[] { auiModel.FunctionId }, false);
if (afiModel == null || afiModel.ID <= 0)
{
throw new ArgumentException(string.Format("FunctionId为：[{0}]的Admin_FunctionInfo表信息为空！", auiModel.FunctionId));
}
var nsiModel = EBS.Interface.Data.DBOper.N_Service_Info.Get("IsDel=0 and Id=@serviceId", "CreateTime desc", new object[] { asaModel.OrderService }, false);
if (nsiModel == null || nsiModel.ID <= 0)
{
throw new ArgumentException(string.Format("ServiceId为：[{0}]的N_Service_Info表信息为空！", asaModel.OrderService));
}
#endregion
var _commandService = ObjectContainer.Resolve <ICommandService>();
var command = new GrabOrderCommand(ObjectId.GenerateNewStringId(), orderId, operSoufunId, operSoufunName, ownerSoufunId);
var result = await _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).TimeOut(20000, "任务超时");
if (result.Status == AsyncTaskStatus.Success)
{
if (!string.IsNullOrEmpty(result.Data.ErrorMessage))
{
return(Json(result.Data.ErrorMessage, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(string.Format("订单编号为：[{0}]的消息发送成功！", orderId), JsonRequestBehavior.AllowGet));
}
}
else
{
if (result.Status == AsyncTaskStatus.IOException)
{
var errJsonStr = CommandExecuteHelper.CreateErrJsonStr(command);
await new ErrMsgDenormalizer().LoggingErrMsgToDb(errJsonStr, result.ErrorMessage, (int)result.Status);
return(Json("服务器异常", JsonRequestBehavior.AllowGet));
}
else
{
return(Json(string.Format("发送失败，错误原因：[{0}]", result.Data.ErrorMessage), JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
public HandlerSelectMiddleware(HandlerDelegate next) : base(next)
{
_commandHandler = ObjectContainer.Resolve <ICommandHandler>();
_queryDelegateFactory = ObjectContainer.Resolve <IQueryServicerDelegateFactory>();
}
protected void LoadExistingData()
{
ObjectContainer.Resolve <IExistingDataManager>()
.Initialize(this.GetType().Assembly);
}
static void WriteChunkPerfTest()
{
ECommonConfiguration
.Create()
.UseAutofac()
.RegisterCommonComponents()
.UseLog4Net()
.RegisterUnhandledExceptionHandler()
.BuildContainer();
var storeRootPath = ConfigurationManager.AppSettings["storeRootPath"]; //文件存储根目录
var threadCount = int.Parse(ConfigurationManager.AppSettings["concurrentThreadCount"]); //并行写数据的线程数
var recordSize = int.Parse(ConfigurationManager.AppSettings["recordSize"]); //记录大小，字节为单位
var recordCount = int.Parse(ConfigurationManager.AppSettings["recordCount"]); //总共要写入的记录数
var syncFlush = bool.Parse(ConfigurationManager.AppSettings["syncFlush"]); //是否同步刷盘
FlushOption flushOption;
Enum.TryParse(ConfigurationManager.AppSettings["flushOption"], out flushOption); //同步刷盘方式
var chunkSize = 1024 * 1024 * 1024;
var flushInterval = 100;
var maxRecordSize = 5 * 1024 * 1024;
var chunkWriteBuffer = 128 * 1024;
var chunkReadBuffer = 128 * 1024;
var chunkManagerConfig = new ChunkManagerConfig(
Path.Combine(storeRootPath, @"sample-chunks"),
new DefaultFileNamingStrategy("message-chunk-"),
chunkSize,
0,
0,
flushInterval,
false,
syncFlush,
flushOption,
Environment.ProcessorCount * 8,
maxRecordSize,
chunkWriteBuffer,
chunkReadBuffer,
5,
1,
1,
5,
10 * 10000,
true);
var chunkManager = new ChunkManager("sample-chunk", chunkManagerConfig, false);
var chunkWriter = new ChunkWriter(chunkManager);
chunkManager.Load(ReadRecord);
chunkWriter.Open();
var record = new BufferLogRecord
{
RecordBuffer = new byte[recordSize]
};
var count = 0L;
var performanceService = ObjectContainer.Resolve <IPerformanceService>();
performanceService.Initialize("WriteChunk").Start();
for (var i = 0; i < threadCount; i++)
{
Task.Factory.StartNew(() =>
{
while (true)
{
var current = Interlocked.Increment(ref count);
if (current > recordCount)
{
break;
}
var start = DateTime.Now;
chunkWriter.Write(record);
performanceService.IncrementKeyCount("default", (DateTime.Now - start).TotalMilliseconds);
}
});
}
Console.ReadLine();
chunkWriter.Close();
chunkManager.Close();
}
public SendQueueMessageService()
{
_ioHelper = ObjectContainer.Resolve <IOHelper>();
_logger = ObjectContainer.Resolve <ILoggerFactory>().Create(GetType().FullName);
}
public TopContext() : base()
{
_contextLifetimeManager = ObjectContainer.Resolve <IContextLifetimeManager>();
}
public virtual void RegisterGlobalContainerDefaults(ObjectContainer container)
{
container.RegisterTypeAs <DefaultRuntimeConfigurationProvider, IRuntimeConfigurationProvider>();
container.RegisterTypeAs <TestRunnerManager, ITestRunnerManager>();
container.RegisterTypeAs <StepFormatter, IStepFormatter>();
container.RegisterTypeAs <TestTracer, ITestTracer>();
container.RegisterTypeAs <DefaultListener, ITraceListener>();
container.RegisterTypeAs <TraceListenerQueue, ITraceListenerQueue>();
container.RegisterTypeAs <ErrorProvider, IErrorProvider>();
container.RegisterTypeAs <RuntimeBindingSourceProcessor, IRuntimeBindingSourceProcessor>();
container.RegisterTypeAs <RuntimeBindingRegistryBuilder, IRuntimeBindingRegistryBuilder>();
container.RegisterTypeAs <SpecFlowAttributesFilter, ISpecFlowAttributesFilter>();
container.RegisterTypeAs <BindingRegistry, IBindingRegistry>();
container.RegisterTypeAs <BindingFactory, IBindingFactory>();
container.RegisterTypeAs <StepDefinitionRegexCalculator, IStepDefinitionRegexCalculator>();
container.RegisterTypeAs <BindingInvoker, IBindingInvoker>();
container.RegisterTypeAs <SynchronousBindingDelegateInvoker, ISynchronousBindingDelegateInvoker>();
container.RegisterTypeAs <TestObjectResolver, ITestObjectResolver>();
container.RegisterTypeAs <StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
container.RegisterTypeAs <DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
container.RegisterTypeAs <StepTextAnalyzer, IStepTextAnalyzer>();
container.RegisterTypeAs <RuntimePluginLoader, IRuntimePluginLoader>();
container.RegisterTypeAs <RuntimePluginLocator, IRuntimePluginLocator>();
container.RegisterTypeAs <RuntimePluginLocationMerger, IRuntimePluginLocationMerger>();
container.RegisterTypeAs <BindingAssemblyLoader, IBindingAssemblyLoader>();
container.RegisterTypeAs <ConfigurationLoader, IConfigurationLoader>();
container.RegisterTypeAs <ObsoleteStepHandler, IObsoleteStepHandler>();
container.RegisterTypeAs <EnvironmentWrapper, IEnvironmentWrapper>();
container.RegisterTypeAs <BinaryFileAccessor, IBinaryFileAccessor>();
container.RegisterTypeAs <TestErrorMessageFactory, ITestErrorMessageFactory>();
container.RegisterTypeAs <TestPendingMessageFactory, ITestPendingMessageFactory>();
container.RegisterTypeAs <TestAmbiguousMessageFactory, ITestAmbiguousMessageFactory>();
container.RegisterTypeAs <TestUndefinedMessageFactory, ITestUndefinedMessageFactory>();
container.RegisterTypeAs <ProtobufFileSinkOutput, IProtobufFileSinkOutput>();
container.RegisterTypeAs <ProtobufFileNameResolver, IProtobufFileNameResolver>();
container.RegisterTypeAs <SinkProvider, ISinkProvider>();
container.RegisterTypeAs <DefaultTestRunContext, ITestRunContext>();
container.RegisterTypeAs <SpecFlowPath, ISpecFlowPath>();
container.RegisterTypeAs <UtcDateTimeClock, IClock>();
container.RegisterTypeAs <CucumberMessageFactory, ICucumberMessageFactory>();
container.RegisterTypeAs <TestResultFactory, ITestResultFactory>();
container.RegisterTypeAs <TestResultPartsFactory, ITestResultPartsFactory>();
container.RegisterTypeAs <PlatformFactory, IPlatformFactory>();
container.RegisterTypeAs <SystemInformationProvider, ISystemInformationProvider>();
container.RegisterTypeAs <SpecFlowVersionInformationProvider, ISpecFlowVersionInformationProvider>();
container.RegisterTypeAs <CucumberMessageSender, ICucumberMessageSender>();
container.RegisterTypeAs <PickleIdGenerator, IPickleIdGenerator>();
container.RegisterTypeAs <PickleIdStore, IPickleIdStore>();
container.RegisterTypeAs <PickleIdStoreDictionaryFactory, IPickleIdStoreDictionaryFactory>();
container.RegisterTypeAs <FieldValueProvider, IFieldValueProvider>();
container.RegisterTypeAs <NonStrictTestRunResultSuccessCalculator, ITestRunResultSuccessCalculator>();
container.RegisterTypeAs <TestRunResultCollector, ITestRunResultCollector>();
container.RegisterTypeAs <FileUserIdStore, IUserUniqueIdStore>();
container.RegisterTypeAs <FileService, IFileService>();
container.RegisterTypeAs <DirectoryService, IDirectoryService>();
container.RegisterTypeAs <EnvironmentSpecFlowTelemetryChecker, IEnvironmentSpecFlowTelemetryChecker>();
container.RegisterTypeAs <AnalyticsTransmitter, IAnalyticsTransmitter>();
container.RegisterTypeAs <HttpClientAnalyticsTransmitterSink, IAnalyticsTransmitterSink>();
container.RegisterTypeAs <AppInsightsEventSerializer, IAppInsightsEventSerializer>();
container.RegisterTypeAs <HttpClientWrapper, HttpClientWrapper>();
container.RegisterTypeAs <AnalyticsEventProvider, IAnalyticsEventProvider>();
}
public static Configuration UseNewtonsoftJson(this Configuration configuration)
{
ObjectContainer.Register<IJsonSerializer,NewtonsoftJsonSerializer>();
return configuration;
}
public void RegisterScenarioContainerDefaults(ObjectContainer scenarioContainer)
{
scenarioContainer.RegisterTypeAs <SpecFlowOutputHelper, ISpecFlowOutputHelper>();
}
public void RegisterDependencies(ObjectContainer container)
{
}
public TestExecutionEngineTests()
{
specFlowConfiguration = ConfigurationLoader.GetDefault();
testThreadContainer = new ObjectContainer();
featureContainer = new ObjectContainer();
scenarioContainer = new ObjectContainer();
beforeScenarioEvents = new List <IHookBinding>();
afterScenarioEvents = new List <IHookBinding>();
beforeStepEvents = new List <IHookBinding>();
afterStepEvents = new List <IHookBinding>();
beforeFeatureEvents = new List <IHookBinding>();
afterFeatureEvents = new List <IHookBinding>();
beforeTestRunEvents = new List <IHookBinding>();
afterTestRunEvents = new List <IHookBinding>();
beforeScenarioBlockEvents = new List <IHookBinding>();
afterScenarioBlockEvents = new List <IHookBinding>();
stepDefinitionSkeletonProviderMock = new Mock <IStepDefinitionSkeletonProvider>();
testObjectResolverMock = new Mock <ITestObjectResolver>();
testObjectResolverMock.Setup(bir => bir.ResolveBindingInstance(It.IsAny <Type>(), It.IsAny <IObjectContainer>()))
.Returns((Type t, IObjectContainer container) => defaultTestObjectResolver.ResolveBindingInstance(t, container));
var culture = new CultureInfo("en-US");
contextManagerStub = new Mock <IContextManager>();
scenarioInfo = new ScenarioInfo("scenario_title", "scenario_description");
scenarioContext = new ScenarioContext(scenarioContainer, scenarioInfo, testObjectResolverMock.Object);
scenarioContainer.RegisterInstanceAs(scenarioContext);
contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext);
featureInfo = new FeatureInfo(culture, "feature_title", "", ProgrammingLanguage.CSharp);
var featureContext = new FeatureContext(featureContainer, featureInfo, specFlowConfiguration);
featureContainer.RegisterInstanceAs(featureContext);
contextManagerStub.Setup(cm => cm.FeatureContext).Returns(featureContext);
contextManagerStub.Setup(cm => cm.StepContext).Returns(new ScenarioStepContext(new StepInfo(StepDefinitionType.Given, "step_title", null, null)));
bindingRegistryStub = new Mock <IBindingRegistry>();
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeStep)).Returns(beforeStepEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterStep)).Returns(afterStepEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenarioBlock)).Returns(beforeScenarioBlockEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenarioBlock)).Returns(afterScenarioBlockEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeFeature)).Returns(beforeFeatureEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterFeature)).Returns(afterFeatureEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeTestRun)).Returns(beforeTestRunEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterTestRun)).Returns(afterTestRunEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenario)).Returns(beforeScenarioEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenario)).Returns(afterScenarioEvents);
specFlowConfiguration = ConfigurationLoader.GetDefault();
errorProviderStub = new Mock <IErrorProvider>();
testTracerStub = new Mock <ITestTracer>();
stepDefinitionMatcherStub = new Mock <IStepDefinitionMatchService>();
methodBindingInvokerMock = new Mock <IBindingInvoker>();
stepErrorHandlers = new Dictionary <string, IStepErrorHandler>();
obsoleteTestHandlerMock = new Mock <IObsoleteStepHandler>();
cucumberMessageSenderMock = new Mock <ICucumberMessageSender>();
cucumberMessageSenderMock.Setup(m => m.SendTestRunStarted())
.Callback(() => { });
_testPendingMessageFactory = new TestPendingMessageFactory(errorProviderStub.Object);
_testUndefinedMessageFactory = new TestUndefinedMessageFactory(stepDefinitionSkeletonProviderMock.Object, errorProviderStub.Object, specFlowConfiguration);
}
private static void RegisterDefaults(ObjectContainer container)
{
DefaultDependencyProvider.RegisterDefaults(container);
}
public ConsumerHeartbeatRequestHandler(BrokerController brokerController)
{
_consumerManager = ObjectContainer.Resolve <ConsumerManager>();
_binarySerializer = ObjectContainer.Resolve <IBinarySerializer>();
}
object FindRoot(string rootString)
{
ObjectContainer container = objectListContainer.FindObjectContainer(rootString);
return(idToObject [container.RefId]);
}
/// <summary>Set the concurrent level for exception scheduler.
/// </summary>
/// <param name="concurrentLevel"></param>
/// <returns></returns>
public ENodeConfiguration SetExceptionSchedulerConcurrentLevel(int concurrentLevel)
{
ObjectContainer.Resolve <IProcessingMessageScheduler <ProcessingPublishableExceptionMessage, IPublishableException, bool> >().SetConcurrencyLevel(concurrentLevel);
return(this);
}
/// <summary>Initialize a new worker with the specified action.
/// </summary>
/// <param name="actionName">The action name.</param>
/// <param name="action">The action to run by the worker.</param>
public Worker(string actionName, Action action)
{
_actionName = actionName;
_action = action;
_logger = ObjectContainer.Resolve <ILoggerFactory>().Create(GetType().FullName);
}
void OnGUI()
{
LWFObject[] lwfObjects =
FindObjectsOfType(typeof(LWFObject)) as LWFObject[];
if (lwfObjects == null || lwfObjects.Length == 0)
{
if (buttonInspector != null)
{
GameObject.DestroyImmediate(buttonInspector.gameObject);
}
return;
}
if (buttonInspector == null)
{
GameObject obj = new GameObject("LWFObjectButtonInspector");
obj.hideFlags = HideFlags.HideAndDontSave;
buttonInspector = obj.AddComponent <LWFObjectButtonInspector>();
buttonInspector.SetVisibilities(visibilities);
}
EditorGUILayout.BeginVertical();
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
foreach (LWFObject lwfObject in lwfObjects)
{
EditorGUI.indentLevel = 0;
LWF.LWF lwf = lwfObject.lwf;
if (lwf == null)
{
continue;
}
string name =
string.Format("{0} / {1}", lwfObject.lwfName, lwf.name);
if (lwf.parent != null)
{
string parentName = lwf.parent.name;
if (parentName == null)
{
parentName = "(null)";
}
string parentFullname = lwf.parent.GetFullName();
if (parentFullname == null)
{
parentFullname = "(null)";
}
name += string.Format(" / attached:{0} on:{1} / {2}",
lwf.attachName, parentName, parentFullname);
}
if (!visibilities.ContainsKey(lwfObject))
{
visibilities[lwfObject] = true;
}
visibilities[lwfObject] =
EditorGUILayout.Foldout(visibilities[lwfObject], name);
if (!visibilities[lwfObject])
{
continue;
}
lwfObject.lwf.Inspect((obj, hierarchy, depth, rOffset) => {
ObjectContainer container =
new ObjectContainer(lwfObject, obj, hierarchy, depth,
obj.lwf.renderingIndex, obj.lwf.renderingCount,
rOffset);
objects[obj] = container;
if (obj.parent != null)
{
objects[obj.parent].objects[depth] = container;
}
});
DrawInspector(objects[lwfObject.lwf.rootMovie]);
}
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
}
void DrawInspector(ObjectContainer container)
{
EditorGUI.indentLevel = container.hierarchy + 1;
LWF.Object obj = container.obj;
LWF.LWF lwf = obj.lwf;
if (obj.type == Type.MOVIE)
{
LWF.Movie movie = (LWF.Movie)obj;
string movieName = "Movie: " +
(movie.name == null ? "(null)" : movie.name);
if (!visibilities.ContainsKey(movie))
{
visibilities[movie] = true;
}
visibilities[movie] =
EditorGUILayout.Foldout(visibilities[movie], movieName);
if (!visibilities[movie])
{
return;
}
EditorGUI.indentLevel = container.hierarchy + 2;
string fullName = movie.GetFullName();
if (fullName == null)
{
fullName = "(null)";
}
EditorGUILayout.LabelField("Fullname:", fullName);
EditorGUILayout.LabelField("Visible:", movie.visible.ToString());
EditorGUILayout.LabelField("Playing:", movie.playing.ToString());
EditorGUILayout.LabelField("Frame:", movie.currentFrame.ToString());
DrawInfo(container, movie);
// TODO
EditorGUILayout.Space();
foreach (KeyValuePair <int, ObjectContainer>
kvp in container.objects)
{
DrawInspector(kvp.Value);
}
}
else
{
EditorGUILayout.LabelField("Depth:", container.depth.ToString());
EditorGUI.indentLevel = container.hierarchy + 2;
switch (obj.type)
{
case Type.BUTTON:
LWF.Button button = (LWF.Button)obj;
string buttonName =
(button.name == null ? "(null)" : button.name);
string buttonFullName = button.GetFullName();
if (buttonFullName == null)
{
buttonFullName = "(null)";
}
EditorGUILayout.LabelField("Button:", buttonName);
EditorGUI.indentLevel = container.hierarchy + 3;
EditorGUILayout.LabelField("Fullname:", buttonFullName);
DrawInfo(container, obj);
// TODO
break;
case Type.GRAPHIC:
EditorGUILayout.LabelField("Graphic:", "");
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
case Type.BITMAP:
LWF.Bitmap bitmap = (LWF.Bitmap)obj;
int tFId = lwf.data.bitmaps[bitmap.objectId].textureFragmentId;
string textureName = (tFId == -1 ? "(null)" :
lwf.data.textureFragments[tFId].filename);
EditorGUILayout.LabelField("Bitmap:", textureName);
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
case Type.BITMAPEX:
LWF.BitmapEx bitmapEx = (LWF.BitmapEx)obj;
int tFIdEx =
lwf.data.bitmapExs[bitmapEx.objectId].textureFragmentId;
string textureNameEx = (tFIdEx == -1 ? "(null)" :
lwf.data.textureFragments[tFIdEx].filename);
EditorGUILayout.LabelField("BitmapEx:", textureNameEx);
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
case Type.TEXT:
LWF.Text text = (LWF.Text)obj;
string textName = lwf.data.strings[
lwf.data.texts[text.objectId].nameStringId];
EditorGUILayout.LabelField("Text:", textName);
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
case Type.PARTICLE:
EditorGUILayout.LabelField("Particle:", "");
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
case Type.PROGRAMOBJECT:
LWF.ProgramObject pObject = (LWF.ProgramObject)obj;
string pObjectName = lwf.data.strings[
lwf.data.programObjects[pObject.objectId].stringId];
EditorGUILayout.LabelField("ProgramObject:", pObjectName);
EditorGUI.indentLevel = container.hierarchy + 3;
DrawInfo(container, obj);
// TODO
break;
}
}
}
public GetMessageDetailByQueueOffsetRequestHandler()
{
_queueStore = ObjectContainer.Resolve <IQueueStore>();
_messageStore = ObjectContainer.Resolve <IMessageStore>();
_binarySerializer = ObjectContainer.Resolve <IBinarySerializer>();
}
/// <summary>Set the concurrent level for domain event scheduler.
/// </summary>
/// <param name="concurrentLevel"></param>
/// <returns></returns>
public ENodeConfiguration SetDomainEventSchedulerConcurrentLevel(int concurrentLevel)
{
ObjectContainer.Resolve <IProcessingMessageScheduler <ProcessingDomainEventStreamMessage, DomainEventStreamMessage, bool> >().SetConcurrencyLevel(concurrentLevel);
return(this);
}
/// <summary>Set the concurrent level for application message scheduler.
/// </summary>
/// <param name="concurrentLevel"></param>
/// <returns></returns>
public ENodeConfiguration SetApplicationMessageSchedulerConcurrentLevel(int concurrentLevel)
{
ObjectContainer.Resolve <IProcessingMessageScheduler <ProcessingApplicationMessage, IApplicationMessage, bool> >().SetConcurrencyLevel(concurrentLevel);
return(this);
}
private void RegisterHandler(Type handlerType)
{
foreach (var handlerInterfaceType in ScanHandlerInterfaces(handlerType))
{
var argumentType = handlerInterfaceType.GetGenericArguments().Single();
var handlerProxyType = GetHandlerProxyType().MakeGenericType(argumentType);
object handler;
if (!_handlerDict.TryGetValue(argumentType, out handler))
{
_handlerDict.Add(argumentType, Activator.CreateInstance(handlerProxyType, new[] { ObjectContainer.Resolve(handlerType) }));
}
}
}
public EmoneyServiceController()
{
db = ObjectContainer.Get <RedisDB>();
}
public RegisterBrokerRequestHandler(NameServerController nameServerController)
{
_clusterManager = nameServerController.ClusterManager;
_binarySerializer = ObjectContainer.Resolve <IBinarySerializer>();
}
public SetQueueNextConsumeOffsetForClusterRequestHandler(NameServerController nameServerController)
{
_binarySerializer = ObjectContainer.Resolve <IBinarySerializer>();
_nameServerController = nameServerController;
}
protected void LoadTemplates()
{
ObjectContainer.Resolve <ITemplateManager>()
.Initialize(this.GetType().Assembly);
}
/// <summary>Set the concurrent level for command scheduler.
/// </summary>
/// <param name="concurrentLevel"></param>
/// <returns></returns>
public ENodeConfiguration SetCommandSchedulerConcurrentLevel(int concurrentLevel)
{
ObjectContainer.Resolve <IProcessingMessageScheduler <ProcessingCommand, ICommand, CommandResult> >().SetConcurrencyLevel(concurrentLevel);
return(this);
}
