search
Found 40 packages
pkg
Yield
Yield - The simplest ASP.NET Static Site Generator (a.k.a. flattener). You just need to make a few minor tweaks to your site configuration, and you're set to generate static HTML.
v0.5.3
↙ 16.0K / total
staticsitegeneratoryieldSSI
AsyncEnumerator
Introduces IAsyncEnumerable, IAsyncEnumerator, ForEachAsync(), and ParallelForEachAsync() GitHub: https://github.com/Dasync/AsyncEnumerable PROBLEM SPACE Helps to (a) create an element provider, where producing an element can take a lot of time due to dependency on other asynchronous events (e.g. wait handles, network streams), and (b) a consumer that processes those element as soon as they are ready without blocking the thread (the processing is scheduled on a worker thread instead). EXAMPLE using Dasync.Collections; static IAsyncEnumerable<int> ProduceAsyncNumbers(int start, int end) { return new AsyncEnumerable<int>(async yield => { // Just to show that ReturnAsync can be used multiple times await yield.ReturnAsync(start); for (int number = start + 1; number <= end; number++) await yield.ReturnAsync(number); // You can break the enumeration loop with the following call: yield.Break(); // This won't be executed due to the loop break above await yield.ReturnAsync(12345); }); } // Just to compare with synchronous version of enumerator static IEnumerable<int> ProduceNumbers(int start, int end) { yield return start; for (int number = start + 1; number <= end; number++) yield return number; yield break; yield return 12345; } static async Task ConsumeNumbersAsync() { var asyncEnumerableCollection = ProduceAsyncNumbers(start: 1, end: 10); await asyncEnumerableCollection.ForEachAsync(async number => { await Console.Out.WriteLineAsync($"{number}"); }); } // Just to compare with synchronous version of enumeration static void ConsumeNumbers() { var enumerableCollection = ProduceNumbers(start: 1, end: 10); foreach (var number in enumerableCollection) { Console.Out.WriteLine($"{number}"); } }
v4.0.2
↙ 29.7M / total
IAsyncEnumerableIAsyncEnumeratorForEachAsyncParallelForEachAsyncasync
org-kevoree-yield-version
Add fields definitions
v7.0.7
↙ 20.7K / total
KevoreeComponentYield
pkg
MyJetWallet.Service.HighYieldEngine.Client
Package Description
v1.2.3
↙ 88.3K / total
Cuemon.Extensions.Collections.Generic✓
The Cuemon.Extensions.Collections.Generic namespace contains extension methods that complements the Cuemon.Collections.Generic namespace while being an addition to the System.Collections.Generic namespace.
v10.4.0
↙ 57.8K / total
extension-methodsextensionsto-partitionerchunkshuffle
pkg
ConcurrencyHelpers
A series of utilities for multithreading. The documentation can be found on http://www.kendar.org/?p=/dotnet/helpers/concurrencyhelpers. Several items are available: LockFree Queue, LockFree Dictionary. A wrapper on the default C# timers to wrap their differences.
v3.3.6
↙ 71.9K / total
C#LockFreeCASInterlockedQueue
pkg
CoroutineCache
Coroutine based cache with areas support, a simple and efficient coroutine implementation. The documentation can be found on http://www.kendar.org/?p=/dotnet/helpers/coroutinecache.
v3.3.6
↙ 33.4K / total
C#LockFreeCASInterlockedQueue
pkg
CallbackYielder
Enumerate items from an arbitrary callback method
v1.2.0
↙ 8.6K / total
Callbacklambdaenumerateitemsevent
pkg
CoroutinesForWpf
Influenced by coroutines in Unity3D. Giving the ability to sequentially declare animations and other time dependent tasks.
v0.3.0
↙ 5.3K / total
c#wpfcoroutineyield
pkg
SingleFile.VB.ExtString.EnumerateLines
VB.NET source file that contains an extension method that yields each line of a given text. The following line separators are recognized: CRLF (0D0A), LFCR (0A0D), LF (0A), CR (0D), VT (0B), FF (0C), LS (2028) and PS (2029). Supported versions: .NET Framework 3.5 .NET Framework 4.0 .NET Framework 4.5 .NET Framework 4.5.1 .NET Framework 4.5.2 .NET Framework 4.6 .NET Framework 4.6.1 Language requirement: Visual Basic 11 (shipped in 2012 with .NET 4.5) This package is part of the "SingleFile.VB" collection that consists of small utilities in the form of VB.NET source files, usually two of them per package, namely the code file and the test file (Microsoft standard unit tests) as well as the license files that are shared over all "Single.VB" packages. Some philosophy: Extension methods and other static utility functions are not shared accross projects resp. assemblies but included wherever they are needed. For that reason they are declared "Friend" and namespace-less as they are supposed to be part of the project's current namespace. Unit test files are added directly to the project and declared "Public" because of limitations of that framework, but they are only compiled in debug mode (through a compiler directive that checks for the "DEBUG" keyword). This allows to keep the tests very near to the code which simplifies access to internal members but does not bulk the published version. The reference to "Microsoft.VisualStudio.TestTools.UnitTesting" (assembly "Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll") is only needed during development and may be declared with "Copy Local = False". The NuGet package version is global across all "Single.VB" packages, and they always reference other packages of the same version (most recent at the time of publishing). This greatly simplifies my dependency handling and therefore improves the quality of the NuGet packages, but may leed to an updated package that does not contain any code change. I apologize for that inconvenience. Your feedback and/or contribution is welcome. Please contact me on singlefile.vb@gmail.com.
v1.0.25
↙ 30.2K / total
SEYR
Simple Entropy Yield Routine
v1.3.31
↙ 30.1K / total
visionAOI
pkg
CoroutineTimeline.Net
lightweight, easy-to-use, and powerful coroutine timeline library for .NET. It lets you write asynchronous operations like a story — no complex state machines, no messy callbacks — just yield your delays and go.
v2.1.0
↙ 1.4K / total
coroutineasyncdelaythread-safeiterator
pkg
xunit.fluently.theoretically
Provides a foundation upon which Xunit Theory Class Data may be generated more succinctly.
v1.0.3.878
↙ 3.4K / total
ElluminationTechnologiesxunittheoryclass
pkg
usleep_win_cs
High-accuracy, low-jitter microsecond sleep for Windows (WaitableTimer + QPC + Yield). .NET 10+ (Windows).
v0.1.1
↙ 42 / total
usleepwindowstimerqpcyield
pkg
xunit.fluently.theoretically.sample
Demonstrates usage of the Xunit.Theoretical Test Cases base class.
v1.0.3.878
↙ 2.7K / total
ElluminationTechnologiesxunittheoryclass
Dirkster.TreeLib
This project produces a .Net Standard Library or .Net 4.0 Library with Generic and IEnumerable/Yield (LevelOrder, PreOrder, PostOrder) tree traversal methods to traverse k-ary trees in different orders via IEnumerable<T>/Yield<T>.
v1.2.0
↙ 25.4K / total
generictreetraversalmethodLevelOrder
pkg
yieldprolog.coda
Description
v1.0.1
↙ 3.1K / total
pkg
CoroutineTimeline-Net
Eas-to-use and lightweight coroutine timeline implementation using C# iterator blocks and async.
v1.0.1
↙ 611 / total
coroutineasyncdelaythread-safeiterator
AsyncEnumerable.Portable
Introduces IAsyncEnumerable, IAsyncEnumerator, ForEachAsync(), and ParallelForEachAsync() GitHub: https://github.com/Dasync/AsyncEnumerable PROBLEM SPACE Helps to (a) create an element provider, where producing an element can take a lot of time due to dependency on other asynchronous events (e.g. wait handles, network streams), and (b) a consumer that processes those element as soon as they are ready without blocking the thread (the processing is scheduled on a worker thread instead). EXAMPLE using Dasync.Collections; static IAsyncEnumerable<int> ProduceAsyncNumbers(int start, int end) { return new AsyncEnumerable<int>(async yield => { // Just to show that ReturnAsync can be used multiple times await yield.ReturnAsync(start); for (int number = start + 1; number <= end; number++) await yield.ReturnAsync(number); // You can break the enumeration loop with the following call: yield.Break(); // This won't be executed due to the loop break above await yield.ReturnAsync(12345); }); } // Just to compare with synchronous version of enumerator static IEnumerable<int> ProduceNumbers(int start, int end) { yield return start; for (int number = start + 1; number <= end; number++) yield return number; yield break; yield return 12345; } static async Task ConsumeNumbersAsync() { var asyncEnumerableCollection = ProduceAsyncNumbers(start: 1, end: 10); await asyncEnumerableCollection.ForEachAsync(async number => { await Console.Out.WriteLineAsync($"{number}"); }); } // Just to compare with synchronous version of enumeration static void ConsumeNumbers() { var enumerableCollection = ProduceNumbers(start: 1, end: 10); foreach (var number in enumerableCollection) { Console.Out.WriteLine($"{number}"); } }
v4.1.1
↙ 26.3K / total
pkg
Kingdom.Collections.ImmutableBitArray
The framework BitArray is helpful but it has a serious flaw in the fact that it is not immutable. This is the primary motivation for working on this package in order to achieve just such an ImmutableBitArray. Reflexive operations can modify an instance but otherwise bitwise operations should yield a wholely new instance.
v2.0.1.7442
↙ 32.4K / total
immutableidempotentbitbitsarray
page 1next →