public PipelineFunctionFactory(HandlerInfo handlerInfo) { _handlerInfo = handlerInfo; _handlerType = handlerInfo.HandlerType; _context = Expression.Parameter(typeof (IContext)); _scopedHandler = Expression.Variable(typeof (IScopedHandler)); _handler = Expression.Variable(_handlerType); }
public SimpleAsyncHandlerResult(IContext context, HandlerInfo handlerInfo, AsyncCallback callback, object asyncState) { _context = context; _handlerInfo = handlerInfo; _callback = callback; AsyncState = asyncState; _helper = new ErrorHelper(context); }
private static IHttpHandler CreateHandler(IContext context, HandlerInfo handlerInfo) { IHttpHandler instance; if (handlerInfo.IsAsync) { instance = CreateAsyncHttpHandler(context, handlerInfo); } else { instance = CreateHttpHandler(context, handlerInfo); } return instance; }
protected void WriteBase(HandlerInfo info, XmlWriter writer) { writer.WriteAttributeString("name", info.Name); foreach (var obj in info.Objects.Values) { if (!_objectWriters.ContainsKey(obj.GetType())) throw new Exception("No writer found for handler object: " + obj.GetType().Name); var objWriter = _objectWriters[obj.GetType()]; objWriter.Write(obj, writer); } }
private void DoUnregisterEvents(object eventSender) { if (eventHandlerDictionary.ContainsKey(eventSender)) { for (int i = eventHandlerDictionary[eventSender].Count - 1; i >= 0; --i) { HandlerInfo handlerInfo = eventHandlerDictionary[eventSender][i]; handlerInfo.EventInfo.RemoveEventHandler(handlerInfo.EventSender, handlerInfo.Handler); } } else { System.Diagnostics.Debug.Print("Event source '{0}' not registered.", eventSender); } }
private static IHttpHandler CreateHttpHandler(IContext context, HandlerInfo handlerInfo) { IHttpHandler instance; if (handlerInfo.RequiresAuthentication) { var authenticationProvider = SimpleWeb.Configuration.Container.Get<IAuthenticationProvider>() ?? new DefaultAuthenticationProvider(); instance = new SimpleHttpHandler(context, handlerInfo); } else { instance = new SimpleHttpHandler(context, handlerInfo); } return instance; }
private static object Invoke(object[] args, HandlerInfo info) { // Use reflection invoke instead of delegate because we have optional parameters if (info.Instance != null) { // Instance function return(info.Method.Invoke(info.Instance, BindingFlags.OptionalParamBinding | BindingFlags.InvokeMethod | BindingFlags.CreateInstance, null, args, null)); } else { // Static function return(info.Method.Invoke(null, BindingFlags.OptionalParamBinding | BindingFlags.InvokeMethod, null, args, null)); } }
private void DoRegisterEvent(object eventSender, EventInfo eventInfo) { string eventName = eventInfo.Name; Delegate handler = new EventHandler <EventArgs>((s, e) => LogRaisedEvent(s, e, eventName)); Delegate eventHandler = Delegate.CreateDelegate(eventInfo.EventHandlerType, handler.Target, handler.Method); eventInfo.AddEventHandler(eventSender, eventHandler); if (!eventHandlerDictionary.ContainsKey(eventSender)) { eventHandlerDictionary.Add(eventSender, new List <HandlerInfo>()); } eventHandlerDictionary[eventSender].Add(HandlerInfo.Create(eventSender, eventInfo, eventHandler)); }
protected void WriteBase(HandlerInfo info, XmlWriter writer) { writer.WriteAttributeString("name", info.Name); foreach (var obj in info.Objects.Values) { if (!_objectWriters.ContainsKey(obj.GetType())) { throw new Exception("No writer found for handler object: " + obj.GetType().Name); } var objWriter = _objectWriters[obj.GetType()]; objWriter.Write(obj, writer); } }
public Task Run(IContext context) { Startup(); IDictionary<string, string> variables; var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.ContentType, context.Request.AcceptTypes, out variables); if (handlerType == null) return null; var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod); foreach (var key in context.Request.QueryString.Select(g => g.Key)) { handlerInfo.Variables.Add(key, context.Request.QueryString[key].FirstOrDefault()); } if (handlerInfo.IsAsync) { var handler = HandlerFactory.Instance.GetHandler(handlerInfo); if (handler != null) { var runner = HandlerRunnerFactory.Instance.GetAsync(handlerInfo.HandlerType, context.Request.HttpMethod); return runner.Start(handler.Handler, context).ContinueWith(t => RunContinuation(t, handler, context, runner)); } throw new InvalidOperationException("Could not create handler."); } else { var tcs = new TaskCompletionSource<object>(); try { using (var handler = HandlerFactory.Instance.GetHandler(handlerInfo)) { if (handler == null) { throw new InvalidOperationException("Could not create handler."); } var run = HandlerRunnerFactory.Instance.Get(handler.Handler.GetType(), context.Request.HttpMethod); run(handler.Handler, context); } tcs.SetResult(null); } catch (Exception ex) { tcs.SetException(ex); } return tcs.Task; } }
public ControllerAction(HandlerInfo handler, string name, string responseType, HttpVerb verb, bool isResponseCollection, string route, params Argument[] requestArguments) : this(name, requestArguments, responseType, verb, isResponseCollection, route, handler.HandlerIType, handler.RequestType, handler.ResponseType) { }
public HandlerInfoViewModel(HandlerInfo handlerInfo) { _handlerInfo = handlerInfo; Name = String.Format("{0}/{1}/{2}", _handlerInfo.PackageName, _handlerInfo.HandlerName, _handlerInfo.JobName); StartCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Start, _handlerInfo.Id)) , o => HandlerState == HandlerState.Stopped || HandlerState == HandlerState.Paused || HandlerState == HandlerState.Idle); StopCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Stop, _handlerInfo.Id)) , o => HandlerState == HandlerState.Running); PauseCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Pause, _handlerInfo.Id)) , o => HandlerState == HandlerState.Running); DisableCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Disable, _handlerInfo.Id)) , o => HandlerState != HandlerState.Disabled); EnableCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Enable, _handlerInfo.Id)) , o => HandlerState == HandlerState.Disabled); DeleteCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Delete, _handlerInfo.Id))); }
/// <summary> /// InsertInfo /// </summary> /// <param name="info"></param> /// <returns></returns> public long InsertInfo(HandlerInfo info) { int cnt = dal.GetCounts("[AJAX_METHOD_NAME] = N'" + info.AjaxMethodName + "'"); if (cnt > 0) { throw new Exception("MC:1x00000024");///客户端函数名不允许重复 } cnt = dal.GetCounts("[SERVER_METHOD_NAME] = N'" + info.ServerMethodName + "'"); if (cnt > 0) { throw new Exception("MC:1x00000023");///服务端函数名不允许重复 } ///TODO:考虑增加启用 return(dal.Add(info)); }
protected static void LoadHandlerBase(HandlerInfo handler, XElement node, string basePath) { handler.Name = node.RequireAttribute("name").Value; foreach (var spriteNode in node.Elements("Sprite")) { var info = new HandlerSpriteInfo(); info.Sprite = LoadSprite(spriteNode, basePath); handler.Objects.Add(info.Name, info); } foreach (var meterNode in node.Elements("Meter")) { var meter = LoadMeter(meterNode, basePath); handler.Objects.Add(meter.Name, meter); } }
public void OnRemoteInvoked(HandlerInfo handlerInfo, object[] args) { var entry = new QueueEntry { HandlerInfo = handlerInfo, InvocationArguments = args, }; if (handlerInfo.Mode == EventQueueMode.Synchronous) { TriggerEvent(entry); } else { _queue.Add(entry); } }
private async Task Save(MessageContext messageContext, HandlerInfo handler, object[] parameters) { foreach (var p in parameters) { switch (p) { case IAggregate a: var repository = serviceProvider.GetRequiredService <IRepository>(); await repository.Save(messageContext, a); break; default: break; } } }
void RemoveDuplicatesBasedOnQueueMode(HandlerInfo handlerInfo, List <QueueEntry> queue) { switch (handlerInfo.Mode) { case EventQueueMode.Synchronous: { // Should not have been queued in the first place Assert.IsEqual(queue.Where(x => x.HandlerInfo == handlerInfo).Count(), 0); break; } case EventQueueMode.All: { // Do nothing, trigger all events break; } case EventQueueMode.LatestOnly: { // Remove all but the last one foreach (var item in queue.Where(x => x.HandlerInfo == handlerInfo).Reverse().Skip(1).ToList()) { queue.Remove(item); } break; } case EventQueueMode.FirstOnly: { // Remove all but the first one foreach (var item in queue.Where(x => x.HandlerInfo == handlerInfo).Skip(1).ToList()) { queue.Remove(item); } break; } default: { Assert.That(false); break; } } }
public void Generate_calls_generator_for_IHandler_with_correct_parameters() { // arrange var methodInfo = GetMethodInfo(nameof(ValidMethodForHandler)); var expectedHandlerInfo = new HandlerInfo(null, null); A.CallTo(() => _handlerStore.Find(typeof(string), typeof(IServerStreamHandler <int, string>), nameof(ValidMethodForHandler))) .Returns(expectedHandlerInfo); // act var result = _generator.Generate(typeof(string), methodInfo); // assert A.CallTo(() => _methodCodeGen.GenerateMethod(Code.MethodServerStreamHandlerCode, nameof(ValidMethodForHandler), typeof(int), typeof(string), expectedHandlerInfo)) .MustHaveHappenedOnceExactly(); }
public void Add_finds_multiple_implementations_using_attribute_on_method() { // arrange _builder.Add(typeof(MultipleWithAttributesHandler), null, null); // expected var expected1 = new HandlerInfo(typeof(MultipleWithAttributesHandler), null); var expected2 = new HandlerInfo(typeof(MultipleWithAttributesHandler), null); // act trying to find by default name var result1 = _builder.Find(typeof(string), typeof(IHandler <string, int>), "OneMethod"); var result2 = _builder.Find(typeof(int), typeof(IHandler <int, string>), "TwoMethod"); // assert result1.Should().BeEquivalentTo(expected1); result2.Should().BeEquivalentTo(expected2); }
public void RegisterHandlers() { var methods = typeof(Test).GetMethods(); var info1 = new HandlerInfo(methods[0]); var info2 = new HandlerInfo(methods[1]); var registry = new HandlerRegistry(); registry.Register(typeof(string), info1); registry.Register(typeof(int), info2); var handlers1 = registry.GetHandlers(typeof(string)); Assert.AreEqual(1, handlers1.Count()); Assert.AreEqual(info1, handlers1.First()); var handlers2 = registry.GetHandlers(typeof(int)); Assert.AreEqual(1, handlers2.Count()); Assert.AreEqual(info2, handlers2.First()); }
private void RegisterMethod(string className, string prefix, MethodInfo m, object instance = null) { var name = prefix + m.Name; if (_handlers.TryGetValue(name, out var existing)) { throw new JsonRpcException($"The method '{name}' is already handled by the class {existing.Instance.GetType().Name}"); } var info = new HandlerInfo { Instance = instance, Method = m, Parameters = m.GetParameters() }; _handlers.TryAdd(name, info); Debug.WriteLine($"Added handler for '{name}' on {className}.{m.Name}"); }
/// <summary> /// Subscribes an instance to events. /// </summary> /// <param name="instance">The instance to subscribe for event publication.</param> public virtual bool Subscribe(object instance) { Should.NotBeNull(instance, "instance"); var handlerInfo = HandlerInfo.GetOrCreate(instance); if (handlerInfo.IsEmpty) { return(false); } lock (_handlerReferences) { if (!Contains(instance, false)) { _handlerReferences.Add(ServiceProvider.WeakReferenceFactory(handlerInfo, true)); } } return(true); }
/// <summary> /// Notifies listener about an event. /// </summary> /// <param name="target">The specified listener to notify.</param> /// <param name="sender">The object that raised the event.</param> /// <param name="message">The message instance.</param> public static void Publish([NotNull] object target, [NotNull] object sender, [NotNull] object message) { Should.NotBeNull(target, "target"); Should.NotBeNull(sender, "sender"); Should.NotBeNull(message, "message"); var handlerInfo = HandlerInfo.GetOrCreate(target); if (!handlerInfo.IsEmpty) { handlerInfo.Handle(sender, message, message is ITracebleMessage); } var customAction = PublishCustomAction; if (customAction != null) { customAction(target, sender, message); } }
public void UnRegisteEvent(EVENT_TYPE eventType, EventDelegate handler) { if (_HandleList.ContainsKey(eventType)) { HandlerInfo handleInfo = null; foreach (var handle in _HandleList[eventType]) { if (handler == handle._EventDelegate) { handleInfo = handle; } } _HandleList[eventType].Remove(handleInfo); if (_HandleList[eventType].Count == 0) { _HandleList.Remove(eventType); } } }
bool checkHandlerV41(HandlerInfo info, out Data41 data41) { data41 = new Data41(); data41.resolveHandler2 = info.handler; data41.resourceField = getLdtokenField(info.handler); if (data41.resourceField == null) { return(false); } bool isOtherRetail; int magicArgIndex = getMagicArgIndex41Retail(info.handler, out isOtherRetail); if (magicArgIndex < 0) { magicArgIndex = getMagicArgIndex41Trial(info.handler); data41.isTrial = true; } var asmVer = module.Assembly.Version; if (magicArgIndex < 0 || magicArgIndex >= info.args.Count) { return(false); } var val = info.args[magicArgIndex]; if (!(val is int)) { return(false); } if (data41.isTrial) { data41.magic = (int)val >> 3; } else if (isOtherRetail) { data41.magic = data41.resourceField.InitialValue.Length - (int)val; } else { data41.magic = ((asmVer.Major << 3) | (asmVer.Minor << 2) | asmVer.Revision) - (int)val; } return(true); }
private void GenerateReadAction(ControllerSourceUnit srcUnit, HandlerInfo handler, CqrsControllerBuilder builder) { if (handler.RequestType.GetProperties().Any(x => x.Name == "Id" || x.Name == $"{handler.Service.Name}Id")) { // this seems to be a query for one record if (!handler.IsResponseCollection) { } else { // this is query for many records } } else { // this seems to be a query for many records. if (!handler.IsResponseCollection) { } else { ArgumentCollection arguments = new ArgumentCollection(); var queryArg = arguments.Add(handler.RequestType.Name.EndsWithSingleSuffix("Request", "Query"), "request", "FromQuery"); // this is query for many records var responseType = handler.ResponseType.Name.EndsWithSingleSuffix("Response", "Result"); builder.AppendAction(handler, "Get", responseType, HttpVerb.Get, handler.IsResponseCollection, $"api/{handler.Service.Name}", arguments.ToArray()); srcUnit.Responses.Append(GenerateResponseType(responseType, handler.ResponseType)); srcUnit.ResultToResponseMappers.Append(GenerateResultToResponseMapper(responseType, handler.ResponseType)); srcUnit.Requests.Append(GenerateRequestType(queryArg.Type, handler.RequestType)); srcUnit.RequestToCommandMappers.Append(GenerateRequestToCommandMapper(queryArg.Type, handler.RequestType)); builder.AddUsing(handler.ResponseType.Namespace + ".WebApi"); builder.AddUsing(handler.RequestType.Namespace + ".WebApi"); builder.AddUsing(handler.ResponseType.Namespace); builder.AddUsing(handler.RequestType.Namespace); } } }
public static IHttpHandler TryCreate(IContext context) { // If it's OPTIONS, we can handle that without any help. if (context.Request.HttpMethod.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase)) { return CreateOptionsHandler(context); } IDictionary<string, string> variables; var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.ContentType, context.Request.AcceptTypes, out variables); if (handlerType == null) return null; var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod); foreach (var key in context.Request.QueryString.Select(g => g.Key)) { handlerInfo.Variables.Add(key, context.Request.QueryString[key].FirstOrDefault()); } return CreateHandler(context, handlerInfo); }
public void RemoveInputHandler(KInputHandler handler) { if (mChildren != null) { int num = 0; while (true) { if (num >= mChildren.Count) { return; } HandlerInfo handlerInfo = mChildren[num]; if (handlerInfo.handler == handler) { break; } num++; } mChildren.RemoveAt(num); } }
protected void LoadBase(HandlerInfo handler, XElement node, string basePath) { handler.Name = node.RequireAttribute("name").Value; var spriteLoader = new SpriteXmlReader(); foreach (var spriteNode in node.Elements("Sprite")) { var info = new HandlerSpriteInfo(); info.Sprite = spriteLoader.LoadSprite(spriteNode, basePath); handler.Objects.Add(info.Name, info); } var meterLoader = new MeterXmlReader(new SceneBindingXmlReader()); foreach (var meterNode in node.Elements("Meter")) { var meter = meterLoader.LoadMeter(meterNode, basePath); handler.Objects.Add(meter.Name, meter); } }
private void okButton_Click(object sender, EventArgs e) { // init things _hi = null; Guid id = Guid.Empty; string location = Path.GetDirectoryName(handlerModuleTextBox.Text); string module = Path.GetFileName(handlerModuleTextBox.Text); string paramts = handlerParametersTextBox.Text; // special handling for python modules. if (0 == string.Compare(Path.GetExtension(handlerModuleTextBox.Text), ".py", true)) { location = ""; module = "Najm.Handler.IPython.dll"; paramts = handlerModuleTextBox.Text; } // try to load handler assembly and get its id try { HandlerAssembly ha = new HandlerAssembly(); ha.Load(location, module, paramts); id = ha.Handler.ID; ha.Unload(); } catch (Exception ex) { string msg = ex.Message + ((ex.InnerException != null && string.IsNullOrEmpty(ex.InnerException.Message)) ? "" : "\n" + ex.InnerException.Message); MessageBox.Show(msg); } finally { if (!id.Equals(Guid.Empty)) { // create handler info _hi = new HandlerInfo(id, location, module, paramts, true); } } }
/// <summary> /// T型のメッセージを処理するハンドラを追加します。 /// </summary> public void AddCommandHandler <TCmd>(PbCommandHandler <TCmd> handler, bool isOutLog = true) { if (handler == null) { return; } lock (this.handlerDic) { var handlerInfo = new HandlerInfo() { Type = typeof(TCmd), ResponseType = null, Handler = (_ => HandleCommandInternal(handler, _)), IsOutLog = isOutLog, }; this.handlerDic.Add(typeof(TCmd), handlerInfo); } }
private static HandlerInfo CreateDefaultHandler() { var info = new HandlerInfo { Namespace = "HelloWorld", Function = "Execute", Entrypoint = "HelloWorld.Main", Code = @" namespace HelloWorld { public class Main { public static string Execute() { return ""Hello, World!""; } } }" }; return(info); }
internal static Task Run(IContext context) { Startup(); if (TryHandleAsStaticContent(context)) { return MakeCompletedTask(); } IDictionary<string, string[]> variables; var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.GetContentType(), context.Request.GetAccept(), out variables); if (handlerType == null) return null; var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod); foreach (var key in context.Request.QueryString.Keys) { handlerInfo.Variables.Add(key, context.Request.QueryString[key]); } var task = PipelineFunctionFactory.Get(handlerInfo)(context); return task ?? MakeCompletedTask(); }
/// <summary> /// T型のリクエストを処理するハンドラを追加します。 /// </summary> public void AddRequestHandler <TReq, TRes>(PbRequestHandler <TReq, TRes> handler, bool isOutLog = true) where TRes : class { if (handler == null) { return; } lock (this.handlerDic) { var handlerInfo = new HandlerInfo() { Type = typeof(TReq), ResponseType = typeof(TRes), Handler = (requestObj) => HandleRequestInternal(handler, requestObj), IsOutLog = isOutLog, }; this.handlerDic.Add(typeof(TReq), handlerInfo); } }
public void HandleKeyUp(KButtonEvent e) { lastConsumedEventUp = null; foreach (Action <KButtonEvent> mOnKeyUpDelegate in mOnKeyUpDelegates) { mOnKeyUpDelegate(e); if (e.Consumed) { lastConsumedEventUp = e; } } if (!e.Consumed && mChildren != null) { foreach (HandlerInfo mChild in mChildren) { HandlerInfo current2 = mChild; current2.handler.HandleKeyUp(e); if (e.Consumed) { break; } } } }
public HandlerInfo GetInfo() { var info = new HandlerInfo(); if (_handlerProxy != null) { // Additional statistics about the running part of the handler var stats = _handlerProxy.GetInfo(); info.JobsAvailable = stats.JobsAvailable; info.JobsPending = stats.JobsPending; info.TotalJobsAvailable = stats.TotalJobsAvailable; info.TotalJobsFailed = stats.TotalJobsFailed; info.TotalJobsProcessed = stats.TotalJobsProcessed; } // General information about the handler info.Id = Id; info.PackageName = JobScript.PackageName; info.HandlerName = HandlerSettings.HandlerName; info.JobName = HandlerSettings.JobName; info.HandlerState = _handlerState; info.LastStartTime = _lastStartTime; info.NextStartTime = NextStartTime; return(info); }
public void AppendAction(HandlerInfo handler, string name, string responseType, HttpVerb verb, bool isResponseCollection, string route, params Argument[] requestArguments) { if (_actions.Any(x => x.Route == route && x.Verb == verb)) { throw new ArgumentException("Route"); } if (string.IsNullOrWhiteSpace(name)) { name = verb.ToString(); } if (string.IsNullOrWhiteSpace(responseType)) { throw new ArgumentNullException("responseType"); } // TODO: add validation and UT _actions.Add(new ControllerAction(handler, name, responseType, verb, isResponseCollection, route, requestArguments)); }
internal SimpleHttpHandler(IContext context, HandlerInfo handlerInfo) { _context = context; _handlerInfo = handlerInfo; }
public RPCStorageFile(string Name) : base(Name) { Info = new RPCStorageInfo(); Cache = DefaultStorageCache; }
static HandlerInfo() { TypeHandlers = new Dictionary <Type, Dictionary <Type, Func <object, object[], object> > >(); EmptyHandler = new HandlerInfo(); CreateDelegate = Create; }
private static IHttpHandler CreateAsyncHttpHandler(IContext context, HandlerInfo handlerInfo) { var instance = new SimpleHttpAsyncHandler(context, handlerInfo); return instance; }
internal static Task Run(IContext context) { Startup(); if (LegacyStaticContentSupport && StaticContent.TryHandleAsStaticContent(context)) { return MakeCompletedTask(); } IDictionary<string, string> variables; var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, out variables, context.Request.GetContentType(), context.Request.GetAccept()); if (handlerType == null) return null; var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod); foreach (var key in context.Request.QueryString.Keys.Where(k => !string.IsNullOrWhiteSpace(k))) { handlerInfo.Variables.Add(key, CombineQueryStringValues(context.Request.QueryString[key])); } var task = PipelineFunctionFactory.Get(handlerInfo.HandlerType, handlerInfo.HttpMethod)(context, handlerInfo); return task ?? MakeCompletedTask(); }
public static Func<IContext, Task> Get(HandlerInfo handlerInfo) { return new PipelineFunctionFactory(handlerInfo).BuildAsyncRunMethod(); }
internal SimpleHttpAsyncHandler(IContext context, HandlerInfo handlerInfo) : this(context, handlerInfo, null) { }
bool CheckHandlerV41(HandlerInfo info, out Data41 data41) { data41 = new Data41(); data41.resolveHandler2 = info.handler; data41.resourceField = GetLdtokenField(info.handler); if (data41.resourceField == null) return false; bool isOtherRetail; int magicArgIndex = GetMagicArgIndex41Retail(info.handler, out isOtherRetail); if (magicArgIndex < 0) { magicArgIndex = GetMagicArgIndex41Trial(info.handler); data41.isTrial = true; } var asmVer = module.Assembly.Version; if (magicArgIndex < 0 || magicArgIndex >= info.args.Count) return false; var val = info.args[magicArgIndex]; if (!(val is int)) return false; if (data41.isTrial) data41.magic = (int)val >> 3; else if (isOtherRetail) data41.magic = data41.resourceField.InitialValue.Length - (int)val; else data41.magic = ((asmVer.Major << 3) | (asmVer.Minor << 2) | asmVer.Revision) - (int)val; return true; }
internal SimpleHttpAsyncHandler(IContext context, HandlerInfo handlerInfo, IAuthenticationProvider authenticationProvider) { _context = context; _handlerInfo = handlerInfo; _authenticationProvider = authenticationProvider; }