/// <summary> /// Register an action to be executed at completion of parsing of a code document. A syntax tree action reports /// diagnostics about the <see cref="SyntaxTree"/> of a document. /// </summary> /// <remarks>This method honors exclusions.</remarks> /// <param name="context">The analysis context.</param> /// <param name="action">Action to be executed at completion of parsing of a document.</param> public static void RegisterSyntaxTreeActionHonorExclusions(this CompilationStartAnalysisContext context, Action <SyntaxTreeAnalysisContext, StyleCopSettings> action) { Compilation compilation = context.Compilation; ConcurrentDictionary <SyntaxTree, bool> cache = GetOrCreateGeneratedDocumentCache(compilation); StrongBox <StyleCopSettings> settingsCache = GetOrCreateStyleCopSettingsCache(compilation); context.RegisterSyntaxTreeAction( c => { if (c.IsGeneratedDocument(cache)) { return; } // Honor the containing document item's ExcludeFromStylecop=True // MSBuild metadata, if analyzers have access to it. //// TODO: code here StyleCopSettings settings = settingsCache.Value; if (settings == null) { StyleCopSettings updatedSettings = SettingsHelper.GetStyleCopSettings(c.Options, c.CancellationToken); StyleCopSettings previous = Interlocked.CompareExchange(ref settingsCache.Value, updatedSettings, null); settings = previous ?? updatedSettings; } action(c, settings); }); }
public unsafe void Read() { var buffer = Writer.Alloc(2048); void *pointer; if (!buffer.Memory.TryGetPointer(out pointer)) { throw new InvalidOperationException("Memory needs to be pinned"); } var data = (IntPtr)pointer; var count = buffer.Memory.Length; var overlapped = ThreadPoolBoundHandle.AllocateNativeOverlapped(PreAllocatedOverlapped); overlapped->OffsetLow = Offset; Overlapped = overlapped; BoxedBuffer = new StrongBox <WritableBuffer>(buffer); int r = ReadFile(FileHandle, data, count, IntPtr.Zero, overlapped); // TODO: Error handling // 997 int hr = Marshal.GetLastWin32Error(); if (hr != 997) { Writer.Complete(Marshal.GetExceptionForHR(hr)); } }
public ReferenceCountedDisposable <TTo> AddReference <TTo>() where TTo : class, IDisposable { WeakReference <T>?weakInstance = _weakInstance; if (weakInstance == null || !weakInstance.TryGetTarget(out var target)) { throw new ObjectDisposedException(nameof(WeakReference)); } StrongBox <int>?referenceCount = _boxedReferenceCount; if (referenceCount == null) { throw new ObjectDisposedException(nameof(WeakReference)); } ReferenceCountedDisposable <TTo>?newReference = TryAddReferenceImpl <T, TTo>(target, referenceCount, out CreateResult result); if (newReference != null) { return(newReference); } throw result switch { CreateResult.Disposed => new ObjectDisposedException(nameof(ReferenceCountedDisposable <T>)), CreateResult.NotCastable => new InvalidCastException(), _ => new NotSupportedException("This exception should never be thrown.") }; } }
/// <inheritdoc /> public override async Task ExecuteAsync(Func <Task> operation, CancellationToken cancellationToken = default) { Requires.NotNull(operation, nameof(operation)); this.ThrowIfFaulted(); StrongBox <bool> ownedBox = this.reentrancyDetection.Value; if (ownedBox?.Value ?? false) { throw Verify.FailOperation("Semaphore is already held and reentrancy setting is '{0}'.", ReentrancyMode.NotAllowed); } await this.ExecuteCoreAsync(async delegate { using (this.joinableTaskCollection?.Join()) { AsyncSemaphore.Releaser releaser = await this.semaphore.EnterAsync(cancellationToken).ConfigureAwait(true); try { this.reentrancyDetection.Value = ownedBox = new StrongBox <bool>(true); await operation().ConfigureAwaitRunInline(); } finally { // Make it clear to any forks of our ExecutionContexxt that the semaphore is no longer owned. ownedBox.Value = false; DisposeReleaserNoThrow(releaser); } } }); }
/// <summary> /// Checks whether the given document is auto generated by a tool /// (based on filename or comment header). /// </summary> /// <remarks> /// <para>The exact conditions used to identify generated code are subject to change in future releases. /// The current algorithm uses the following checks.</para> /// <para>Code is considered generated if it meets any of the following conditions.</para> /// <list type="bullet"> /// <item>The code is contained in a file which starts with a comment containing the text /// <c><auto-generated</c>.</item> /// <item>The code is contained in a file with a name matching certain patterns (case-insensitive): /// <list type="bullet"> /// <item>*.designer.cs</item> /// </list> /// </item> /// </list> /// </remarks> /// <param name="tree">The syntax tree to examine.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param> /// <returns> /// <para><see langword="true"/> if <paramref name="tree"/> is located in generated code; otherwise, /// <see langword="false"/>. If <paramref name="tree"/> is <see langword="null"/>, this method returns /// <see langword="false"/>.</para> /// </returns> public static bool IsGeneratedDocument(this SyntaxTree tree, CancellationToken cancellationToken) { bool result = false; if (tree != null) { StrongBox <bool?> cachedResult = GeneratedHeaderPresentCheck.GetOrCreateValue(tree); if (cachedResult.Value.HasValue) { result = cachedResult.Value.Value; } else { bool autoGenerated = IsGeneratedDocumentNoCache(tree, cancellationToken); // Update the strongbox's value with our computed result. // This doesn't change the strongbox reference, and its presence in the // ConditionalWeakTable is already assured, so we're updating in-place. // In the event of a race condition with another thread that set the value, // we'll just be re-setting it to the same value. cachedResult.Value = autoGenerated; result = autoGenerated; } } return(result); }
internal void BoxLocals() { var boxedLocals = Interpreter._boxedLocals; for (int i = 0; i < boxedLocals.Length; i++) { int index = boxedLocals[i]; Data[index] = new StrongBox<object>(Data[index]); } }
public override int Run(InterpretedFrame frame) { StrongBox <object> box = frame.Closure[base._index]; frame.Data[frame.StackIndex++] = box; return(1); }
public static async Task WhenAny() { var box = new StrongBox <int>(0); var source1 = new ValueTaskCompletionSource(); var source2 = new ValueTaskCompletionSource(); var source3 = new ValueTaskCompletionSource(); ThreadPool.QueueUserWorkItem(state => { box.Value.VolatileWrite(1); Thread.Sleep(50); source1.Complete(); }); ThreadPool.QueueUserWorkItem(state => { box.Value.VolatileWrite(2); Thread.Sleep(200); source2.Complete(); }); ThreadPool.QueueUserWorkItem(state => { box.Value.VolatileWrite(3); Thread.Sleep(150); source3.Complete(); }); var completedTask = await ValueTaskSynchronization.WhenAny(source1.Task, source2.Task, source3.Task); True(completedTask == source1.Task); False(completedTask == source2.Task); False(completedTask == source3.Task); }
/// <summary>Creates a value for the current thread and stores it in the central list of values.</summary> /// <returns>The boxed value.</returns> private StrongBox <T> CreateValue() { var s = new StrongBox <T>(_seedFactory != null ? _seedFactory() : default(T)); _values.Enqueue(s); return(s); }
public void EqualityComparer_IEqualityComparerEqualsWithObjectsNotOfMatchingType() { // EqualityComparer<T> implements IEqualityComparer for back-compat reasons. // The explicit implementation of IEqualityComparer.Equals(object, object) should // throw if the inputs are not reference-equal, both non-null and either of them // is not of type T. IEqualityComparer comparer = EqualityComparer <T> .Default; StrongBox <T> notOfTypeT = new StrongBox <T>(default(T)); Assert.True(comparer.Equals(default(T), default(T))); // This should not throw since both inputs will either be null or Ts. Assert.True(comparer.Equals(notOfTypeT, notOfTypeT)); // This should not throw since the inputs are reference-equal. // Null inputs should never raise an exception. Assert.Equal(default(T) == null, comparer.Equals(default(T), null)); Assert.Equal(default(T) == null, comparer.Equals(null, default(T))); Assert.True(comparer.Equals(null, null)); if (default(T) != null) // if default(T) is null this assert will fail as IEqualityComparer.Equals returns early if either input is null { AssertExtensions.Throws <ArgumentException>(null, () => comparer.Equals(notOfTypeT, default(T))); // lhs is the problem AssertExtensions.Throws <ArgumentException>(null, () => comparer.Equals(default(T), notOfTypeT)); // rhs is the problem } if (!(notOfTypeT is T)) // catch cases where StrongBox<T> actually is a T, such as T == object { AssertExtensions.Throws <ArgumentException>(null, () => comparer.Equals(notOfTypeT, new StrongBox <T>(default(T)))); } }
public override int Run(InterpretedFrame frame) { StrongBox <object> box = frame.Closure[base._index]; box.Value = frame.Peek(); return(1); }
internal StringSwitchInstruction(Dictionary <string, int> cases, StrongBox <int> nullCase) { Assert.NotNull(cases); Assert.NotNull(nullCase); _cases = cases; _nullCase = nullCase; }
public void TestCollectionConstructorUsesCorrectComparer() { var key1 = new StrongBox <int>(1); var key2 = new StrongBox <int>(2); KeyValuePair <StrongBox <int>, int>[] pairs = { new KeyValuePair <StrongBox <int>, int>(key1, 1), new KeyValuePair <StrongBox <int>, int>(key2, 2), }; var comparer = new ComparisonComparer <StrongBox <int> >((x, y) => Comparer <int> .Default.Compare(x.Value, y.Value)); var objectDictionary = ImmutableSortedTreeDictionary.CreateRange(comparer, pairs); Assert.Same(comparer, objectDictionary.KeyComparer); Assert.Equal(2, objectDictionary.Count); Assert.Equal(new[] { new KeyValuePair <StrongBox <int>, int>(key1, 1), new KeyValuePair <StrongBox <int>, int>(key2, 2) }, objectDictionary); var stringDictionary = ImmutableSortedTreeDictionary.Create <string, int>(); Assert.Same(Comparer <string> .Default, stringDictionary.KeyComparer); stringDictionary = ImmutableSortedTreeDictionary.Create <string, int>(StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, stringDictionary.KeyComparer); KeyValuePair <StrongBox <int>, int>[] pairsWithDuplicateKey = { new KeyValuePair <StrongBox <int>, int>(key1, 1), new KeyValuePair <StrongBox <int>, int>(key2, 2), new KeyValuePair <StrongBox <int>, int>(key1, 3), }; Assert.Throws <ArgumentException>(() => ImmutableSortedTreeDictionary.CreateRange(comparer, pairsWithDuplicateKey)); }
public void Saving_Example() { using (var f = new TempfileLife()) { var rpath = JsonSettings.ResolvePath(f); StrongBox <int> saved = new StrongBox <int>(0); var o = JsonSettings.Load <ExampleNotifyingSettings>(f).EnableAutosave(); saved.Value.Should().Be(0); o.AfterSave += (s, destinition) => { saved.Value++; }; o.Residents.Add("Cookie Monster"); //Boom! saves. saved.Value.Should().Be(1); o.Residents = new ObservableCollection <string>(); //Boom! saves. saved.Value.Should().Be(2); o.Residents.Add("Cookie Monster"); //Boom! saves. saved.Value.Should().Be(3); o.NonAutosavingProperty = new ObservableCollection <object>(); //doesn't save o.NonAutosavingProperty.Add("Jim"); //doesn't save saved.Value.Should().Be(3); o.Street += "-1"; //Boom! saves. saved.Value.Should().Be(4); o.AutoProperty = "Hello"; //Boom! saves. saved.Value.Should().Be(5); o.IgnoredFromAutosaving = "Hello"; //doesn't save saved.Value.Should().Be(5); } }
public static async Task ThrowInCatchBlock() { var result = new StrongBox <int>(); var lambda = AsyncLambda <Func <StrongBox <int>, Task> >(fun => { Try(() => { Await(Expression.Call(typeof(Task), nameof(Task.Yield), Type.EmptyTypes)); Throw <InvalidOperationException>(); }) .Catch(typeof(InvalidOperationException), e => { Throw <ArithmeticException>(); }) .Finally(() => { Assign(Expression.Field(fun[0], "Value"), 45.Const()); }) .End(); }).Compile(); await ThrowsAsync <ArithmeticException>(() => lambda(result)); Equal(45, result.Value); }
public void Case2() { using (var f = new TempfileLife()) { StrongBox <bool> saved = new StrongBox <bool>(false); var o = JsonSettings.Load <AutosaveTests.Settings>(f.FileName) .EnableAutosave(); o.AfterSave += (s, destinition) => { saved.Value = true; }; var module = o.Modulation.GetModule <AutosaveModule>(); //act module.AutosavingState.Should().Be(AutosavingState.Running); var suspender = o.SuspendAutosave(); module.AutosavingState.Should().Be(AutosavingState.Suspended); saved.Value.ShouldBeEquivalentTo(false); o.property = "hi"; saved.Value.ShouldBeEquivalentTo(false); module.AutosavingState.Should().Be(AutosavingState.SuspendedChanged); suspender.Resume(); //resuming/disposing twice should have any effect saved.Value.ShouldBeEquivalentTo(true); saved.Value = false; suspender.Resume(); saved.Value.ShouldBeEquivalentTo(false); } }
private static XElement CreateElementForCompilation(Compilation compilation) { StrongBox <int> compilationId; if (!s_CompilationIds.TryGetValue(compilation, out compilationId)) { compilationId = new StrongBox <int>(s_NextCompilationId++); s_CompilationIds.Add(compilation, compilationId); } var namespaces = new Queue <INamespaceSymbol>(); var typesElement = new XElement("types"); namespaces.Enqueue(compilation.Assembly.GlobalNamespace); while (namespaces.Count > 0) { var @ns = namespaces.Dequeue(); foreach (var type in @ns.GetTypeMembers()) { typesElement.Add(new XElement("type", new XAttribute("name", type.ToDisplayString()))); } foreach (var childNamespace in @ns.GetNamespaceMembers()) { namespaces.Enqueue(childNamespace); } } return(new XElement("compilation", new XAttribute("objectId", compilationId.Value), new XAttribute("assemblyIdentity", compilation.Assembly.Identity.ToString()), typesElement)); }
public DelayedTupleExpression(int index, StrongBox <ParameterExpression> tupleExpr, StrongBox <Type> tupleType, Type type) { Index = index; _tupleType = tupleType; _tupleExpr = tupleExpr; _type = type; }
/// <summary>Creates a value for the current thread and stores it in the central list of values.</summary> /// <returns>The boxed value.</returns> private StrongBox <T> CreateValue() { StrongBox <T> item = new StrongBox <T>((this._seedFactory != null) ? this._seedFactory() : default(T)); this._values.Enqueue(item); return(item); }
private ReferenceCountedDisposable(T instance, StrongBox <int> referenceCount) { _instance = instance ?? throw new ArgumentNullException(nameof(instance)); // The reference count has already been incremented for this instance _boxedReferenceCount = referenceCount; }
internal static bool ContainsUsingAlias(this SyntaxTree tree) { if (tree == null) { return(false); } StrongBox <bool?> cachedResult = UsingAliasPresentCheck.GetOrCreateValue(tree); if (cachedResult.Value.HasValue) { return(cachedResult.Value.Value); } bool hasUsingAlias = ContainsUsingAliasNoCache(tree); // Update the strongbox's value with our computed result. // This doesn't change the strongbox reference, and its presence in the // ConditionalWeakTable is already assured, so we're updating in-place. // In the event of a race condition with another thread that set the value, // we'll just be re-setting it to the same value. cachedResult.Value = hasUsingAlias; return(hasUsingAlias); }
public unsafe void Read() { var buffer = Writer.Alloc(2048); fixed(byte *source = &buffer.Buffer.Span.DangerousGetPinnableReference()) { var count = buffer.Buffer.Length; var overlapped = ThreadPoolBoundHandle.AllocateNativeOverlapped(PreAllocatedOverlapped); overlapped->OffsetLow = Offset; Overlapped = overlapped; BoxedBuffer = new StrongBox <WritableBuffer>(buffer); int r = ReadFile(FileHandle, (IntPtr)source, count, IntPtr.Zero, overlapped); // TODO: Error handling // 997 int hr = Marshal.GetLastWin32Error(); if (hr != 997) { Writer.Complete(Marshal.GetExceptionForHR(hr)); } } }
/// <summary> /// Provides the implementation for <see cref="TryAddReference"/> and /// <see cref="WeakReference.TryAddReference"/>. /// </summary> private static ReferenceCountedDisposable <T> TryAddReferenceImpl(T target, StrongBox <int> referenceCount) { lock (referenceCount) { if (referenceCount.Value == 0) { // The target is already disposed, and cannot be reused return(null); } if (target == null) { // The current reference has been disposed, so even though it isn't disposed yet we don't have a // reference to the target return(null); } checked { referenceCount.Value++; } // Must return a new instance, in order for the Dispose operation on each individual instance to // be idempotent. return(new ReferenceCountedDisposable <T>(target, referenceCount)); } }
public async void TestShutdown() { var index = new StrongBox <int>(); var clientManager = new TestClientConnectionManager(index); var serviceManager = new TestServiceConnectionManager <Hub>(index); var options = new TestOptions(); options.Value.GracefulShutdown = new GracefulShutdownOptions() { Timeout = TimeSpan.FromSeconds(1), Mode = GracefulShutdownMode.WaitForClientsClose }; var dispatcher = new ServiceHubDispatcher <Hub>( null, serviceManager, clientManager, null, options, NullLoggerFactory.Instance, new TestRouter(), null, null, null ); await dispatcher.ShutdownAsync(); Assert.Equal(3, serviceManager.StopIndex); Assert.Equal(2, clientManager.CompleteIndex); Assert.Equal(1, serviceManager.OfflineIndex); }
private Node(int nbLevels, TK key, TV value) { NbLevels = nbLevels; Key = key; Forward = new ForwardNodesCollection(nbLevels); Data = new StrongBox <TV>(value); }
public async Task MultipleWorkers_Limited_1() { var max = new StrongBox <int>(0); var queue = Using(new HybridDbMessageQueue( store, MaxConcurrencyCounter(max), new MessageQueueOptions { MaxConcurrency = 1 }.ReplayEvents(TimeSpan.FromSeconds(60)))); using (var session = store.OpenSession()) { foreach (var i in Enumerable.Range(1, 200)) { session.Enqueue(new MyMessage(Guid.NewGuid().ToString(), i.ToString())); } session.SaveChanges(); } var threads = await queue.Events.OfType <MessageHandled>() .Take(200) .ToList() .FirstAsync(); max.Value.ShouldBe(1); }
internal Delegate CreateDelegate(StrongBox<object>[] closure) { if (_compiled != null) { // If the delegate type we want is not a Func/Action, we can't // use the compiled code directly. So instead just fall through // and create an interpreted LightLambda, which will pick up // the compiled delegate on its first run. // // Ideally, we would just rebind the compiled delegate using // Delegate.CreateDelegate. Unfortunately, it doesn't work on // dynamic methods. if (SameDelegateType) { return CreateCompiledDelegate(closure); } } if (_interpreter == null) { // We can't interpret, so force a compile Compile(null); Delegate compiled = CreateCompiledDelegate(closure); Debug.Assert(compiled.GetType() == _lambda.Type); return compiled; } // Otherwise, we'll create an interpreted LightLambda return new LightLambda(this, closure, _interpreter._compilationThreshold).MakeDelegate(_lambda.Type); }
internal static RubyArray SortInPlace( BinaryOpStorage /*!*/ comparisonStorage, BinaryOpStorage /*!*/ lessThanStorage, BinaryOpStorage /*!*/ greaterThanStorage, BlockParam block, RubyArray /*!*/ self, out StrongBox <object> breakResult) { breakResult = null; var context = comparisonStorage.Context; // TODO: this does more comparisons (and in a different order) than // Ruby's sort. Also, control flow won't work because List<T>.Sort wraps // exceptions from the comparer & rethrows. We need to rewrite a version of quicksort // that behaves like Ruby's sort. if (block == null) { self.Sort((x, y) => Protocols.Compare(comparisonStorage, lessThanStorage, greaterThanStorage, x, y)); } else { object nonRefBreakResult = null; try { self.Sort((x, y) => { object result = null; if (block.Yield(x, y, out result)) { nonRefBreakResult = result; throw new BreakException(); } if (result == null) { throw RubyExceptions.MakeComparisonError(context, x, y); } return(Protocols.ConvertCompareResult(lessThanStorage, greaterThanStorage, result)); }); } catch (InvalidOperationException e) { if (e.InnerException == null) { throw; } if (e.InnerException is BreakException) { breakResult = new StrongBox <object>(nonRefBreakResult); return(null); } else { throw e.InnerException; } } } return(self); }
public void CanAddSuffix() { var structure = new StructureTest.TestStructure(); var strongBox = new StrongBox <bool>(false); structure.TestAddInstanceSuffix("FOO", new Suffix <bool>(BuildBasicGetter(strongBox))); Assert.IsFalse((bool)structure.GetSuffix("FOO")); }
private static void StrongBoxDemo() { StrongBox <int> sint = new StrongBox <int>(123465); Console.WriteLine(sint.Value); StrongBoxInt(sint); Console.WriteLine(sint.Value); }
protected override void Dispose(bool disposing) { if (_pinned != null) { _pinned.Value.Free(); _pinned = null; } }
public static PhonesActivityWindowManger Init(int window, int numOfNodes, int amsVectorLength, HashFunctionTable[] hashFunctionTable, PhonesActivityDataParser phonesActivityDataParser, GeographicalDistributing distributingMethod) { StrongBox <PhonesActivityWindowManger> phonesActivityWindowManager = new StrongBox <PhonesActivityWindowManger>(null); var lazyWindow = new Lazy <WindowedStatistics>(() => WindowedStatistics.Init(ArrayUtils.Init(window, _ => phonesActivityWindowManager.Value.GetNextAmsVectors()))); phonesActivityWindowManager.Value = new PhonesActivityWindowManger(numOfNodes, amsVectorLength, hashFunctionTable, phonesActivityDataParser, lazyWindow, distributingMethod); return(phonesActivityWindowManager.Value); }
internal Delegate CreateCompiledDelegate(StrongBox<object>[] closure) { if (this.HasClosure) { Func<StrongBox<object>[], Delegate> func = (Func<StrongBox<object>[], Delegate>) this._compiled; return func(closure); } return this._compiled; }
internal void BoxLocals() { bool[] boxedLocals = Interpreter._localIsBoxed; if (boxedLocals != null) { for (int i = 0; i < boxedLocals.Length; i++) { if (boxedLocals[i]) { Data[i] = new StrongBox<object>(Data[i]); } } } }
public static void TestCtor() { StrongBox<int> boxedInt32 = new StrongBox<int>(); Assert.Equal(default(int), boxedInt32.Value); boxedInt32 = new StrongBox<int>(42); Assert.Equal(42, boxedInt32.Value); StrongBox<string> boxedString = new StrongBox<string>(); Assert.Equal(default(string), boxedString.Value); boxedString = new StrongBox<string>("test"); Assert.Equal("test", boxedString.Value); }
internal InterpretedFrame(Interpreter interpreter, StrongBox<object>[] closure) { Interpreter = interpreter; StackIndex = interpreter.Locals.LocalCount; Data = new object[StackIndex + interpreter.Instructions.MaxStackDepth]; int c = interpreter.Instructions.MaxContinuationDepth; if (c > 0) { _continuations = new int[c]; } Closure = closure; }
internal Delegate CreateDelegate(StrongBox<object>[] closure) { if ((this._compiled != null) && this.SameDelegateType) { return this.CreateCompiledDelegate(closure); } if (this._interpreter == null) { this.Compile(null); return this.CreateCompiledDelegate(closure); } return new LightLambda(this, closure, this._interpreter._compilationThreshold).MakeDelegate(this.DelegateType); }
internal InterpretedFrame(System.Management.Automation.Interpreter.Interpreter interpreter, StrongBox<object>[] closure) { this.Interpreter = interpreter; this.StackIndex = interpreter.LocalCount; this.Data = new object[this.StackIndex + interpreter.Instructions.MaxStackDepth]; int maxContinuationDepth = interpreter.Instructions.MaxContinuationDepth; if (maxContinuationDepth > 0) { this._continuations = new int[maxContinuationDepth]; } this.Closure = closure; this._pendingContinuation = -1; this._pendingValue = System.Management.Automation.Interpreter.Interpreter.NoValue; }
public static void TestValue() { StrongBox<int> sb = new StrongBox<int>(); Assert.Equal(0, sb.Value); sb.Value = 42; Assert.Equal(42, sb.Value); IStrongBox isb = sb; Assert.Equal(42, (int)isb.Value); isb.Value = 84; Assert.Equal(84, sb.Value); Assert.Equal(84, (int)isb.Value); Assert.Throws<InvalidCastException>(() => isb.Value = "test"); }
private Delegate CreateCompiledDelegate(StrongBox<object>[] closure) { // It's already compiled, and the types match, just use the // delegate directly. Delegate d = _compiled(closure); // The types might not match, if the delegate type we want is // not a Func/Action. In that case, use LightLambda to create // a new delegate of the right type. This is not the most // efficient approach, but to do better we need the ability to // compile into a DynamicMethod that we created. if (d.GetType() != _lambda.Type) { var ret = new LightLambda(_interpreter, closure, this); ret.Compiled = d; d = ret.MakeDelegate(_lambda.Type); } return d; }
public override int Run(InterpretedFrame frame) { StrongBox<object>[] boxArray; if (this.ConsumedStack > 0) { boxArray = new StrongBox<object>[this.ConsumedStack]; for (int i = boxArray.Length - 1; i >= 0; i--) { boxArray[i] = (StrongBox<object>) frame.Pop(); } } else { boxArray = null; } Delegate delegate2 = this._creator.CreateDelegate(boxArray); frame.Push(delegate2); return 1; }
private HistorySavingComponent() { // Initialize the workqueue. this.queue = new WorkQueue(); // Disallow the concurrency for this component. this.queue.ConcurrentLimit = 1; // Log the event if an item failed. this.queue.FailedWorkItem += onFailedWorkItem; // Initiate the component timer. this.timer = new ComponentTimer( TIME_INTERVAL, TimeUpHandler); // Initialize the logger used in this component. logger = NLoggerUtil.GetNLogger(typeof (HistorySavingComponent)); activeDocumentBox = new StrongBox<IDocument>(); }
internal Delegate CreateDelegate(StrongBox<object>[] closure) { if (_compiled != null) { return CreateCompiledDelegate(closure); } // Otherwise, we'll create an interpreted LightLambda var ret = new LightLambda(_interpreter, closure, this); lock (this) { // If this field is now null, it means a compile happened if (_lightLambdas != null) { _lightLambdas.Add(ret); } } if (_lightLambdas == null) { return CreateCompiledDelegate(closure); } return ret.MakeDelegate(_lambda.Type); }
internal InterpretedFrame(Interpreter interpreter, StrongBox<object>[] closure) { Interpreter = interpreter; StackIndex = interpreter._numberOfLocals; Data = new object[interpreter._numberOfLocals + interpreter._maxStackDepth]; Closure = closure; }
public ImportStatementInfo(Statement statement, StrongBox<int> siblings) { Statement = statement; Siblings = siblings; }
public DelayedTupleExpression(int index, StrongBox<ParameterExpression> tupleExpr, StrongBox<Type> tupleType, Type type) { Index = index; _tupleType = tupleType; _tupleExpr = tupleExpr; _type = type; }
private void TrackImport(Statement node, string name) { var parent = _scopes[_scopes.Count - 1]; StrongBox<int> statementCount; if (!_statementCount.TryGetValue(parent, out statementCount)) { PythonAst outerParent = parent as PythonAst; if (outerParent != null) { // we don't care about the number of children at the top level statementCount = new StrongBox<int>(-1); } else { FunctionDefinition funcDef = parent as FunctionDefinition; if (funcDef != null) { statementCount = GetNumberOfChildStatements(funcDef.Body); } else { var classDef = (ClassDefinition)parent; statementCount = GetNumberOfChildStatements(classDef.Body); } } _statementCount[parent] = statementCount; } List<ImportStatementInfo> imports; if (!_importedNames.TryGetValue(name, out imports)) { _importedNames[name] = imports = new List<ImportStatementInfo>(); } imports.Add(new ImportStatementInfo(node, statementCount)); }
/// <summary> /// Used by LightLambda to get the compiled delegate. /// </summary> internal Delegate CreateCompiledDelegate(StrongBox<object>[] closure) { Debug.Assert(HasClosure == (closure != null)); if (HasClosure) { // We need to apply the closure to get the actual delegate. var applyClosure = (Func<StrongBox<object>[], Delegate>)_compiled; return applyClosure(closure); } return _compiled; }
public ImportRemovalInfo(ImportStatementInfo statementInfo) { var node = statementInfo.Statement; SiblingCount = statementInfo.Siblings; if (node is FromImportStatement) { Statement = new RemovedFromImportStatement((FromImportStatement)node); } else { Statement = new RemovedImportStatement((ImportStatement)node); } }
// Silverlight doesn't have ModuleInfo.ResolveField so we need to // get something which can be updated w/ the final type instead. public FieldBuilderExpression(FieldBuilder builder, StrongBox<Type> finishedType) { _builder = builder; _finishedType = finishedType; }
public UpdateActiveDocumentWorkItem(StrongBox<IDocument> documentBox, IDocument document) { this.documentBox = documentBox; this.document = document; }
public EnumerableTest(StrongBox<bool> disposed) { _disposed = disposed; }
public static RubyRegex/*!*/ CreateRegexN(object[]/*!*/ strings, RubyEncoding/*!*/ encoding, RubyRegexOptions options, StrongBox<RubyRegex> regexpCache) { Func<RubyRegex> createRegex = delegate { return new RubyRegex(CreateMutableStringN(strings, encoding), options); }; return CreateRegexWorker(options, regexpCache, false, createRegex); }
internal static RubyArray SortInPlace(ComparisonStorage/*!*/ comparisonStorage, BlockParam block, RubyArray/*!*/ self, out StrongBox<object> breakResult) { breakResult = null; var context = comparisonStorage.Context; // TODO: this does more comparisons (and in a different order) than // Ruby's sort. Also, control flow won't work because List<T>.Sort wraps // exceptions from the comparer & rethrows. We need to rewrite a version of quicksort // that behaves like Ruby's sort. if (block == null) { self.Sort((x, y) => Protocols.Compare(comparisonStorage, x, y)); } else { object nonRefBreakResult = null; try { self.Sort((x, y) => { object result = null; if (block.Yield(x, y, out result)) { nonRefBreakResult = result; throw new BreakException(); } if (result == null) { throw RubyExceptions.MakeComparisonError(context, x, y); } return Protocols.ConvertCompareResult(comparisonStorage, result); }); } catch (InvalidOperationException e) { if (e.InnerException == null) { throw; } if (e.InnerException is BreakException) { breakResult = new StrongBox<object>(nonRefBreakResult); return null; } else { throw e.InnerException; } } } return self; }
public MyEnumerator(StrongBox<bool> disposed) { _disposed = disposed; }
internal StackFrame MakeFrame(StrongBox<object>[] closure) { var ret = new StackFrame(_numberOfLocals, _maxStackDepth); ret.Closure = closure; return ret; }
static void Assign5() { Title(); var box = new StrongBox<int> { Value = 3 }; var obj = Log(Expression.Constant(box), "Box"); var val = box.GetType().GetField("Value"); var fld = Expression.Field(obj, val); var res = Expression.Lambda<Func<int>>(CSharpExpression.PreIncrementAssignChecked(fld)).Compile()(); Console.WriteLine($"{res} == (++3) --> {box.Value}"); }
public unsafe void Read() { var buffer = Writer.Alloc(2048); void* pointer; if (!buffer.Memory.TryGetPointer(out pointer)) { throw new InvalidOperationException("Memory needs to be pinned"); } var data = (IntPtr)pointer; var count = buffer.Memory.Length; var overlapped = ThreadPoolBoundHandle.AllocateNativeOverlapped(PreAllocatedOverlapped); overlapped->OffsetLow = Offset; Overlapped = overlapped; BoxedBuffer = new StrongBox<WritableBuffer>(buffer); int r = ReadFile(FileHandle, data, count, IntPtr.Zero, overlapped); // TODO: Error handling // 997 int hr = Marshal.GetLastWin32Error(); if (hr != 997) { Writer.Complete(Marshal.GetExceptionForHR(hr)); } }
private static RubyRegex/*!*/ CreateRegexWorker( RubyRegexOptions options, StrongBox<RubyRegex> regexpCache, bool isLiteralWithoutSubstitutions, Func<RubyRegex> createRegex) { try { bool once = ((options & RubyRegexOptions.Once) == RubyRegexOptions.Once) || isLiteralWithoutSubstitutions; if (once) { // Note that the user is responsible for thread synchronization if (regexpCache.Value == null) { regexpCache.Value = createRegex(); } return regexpCache.Value; } else { // In the future, we can consider caching the last Regexp. For some regexp literals // with substitution, the substition will be the same most of the time return createRegex(); } } catch (RegexpError e) { if (isLiteralWithoutSubstitutions) { // Ideally, this should be thrown during parsing of the source, even if the // expression happens to be unreachable at runtime. throw new SyntaxError(e.Message); } else { throw; } } }