public override void Update(DBObject dbobject)
{
string sqlcmd = "UPDATE " + dbobject.GetType().Name + " SET ";
ParallelQuery <PropertyInfo> pinfo = dbobject.GetType().GetProperties().AsParallel().Where(x => WhereNotNull(x, dbobject));
pinfo.ForAll(x => sqlcmd += x.Name + " = " + x.GetValue(dbobject, null) + ", ");
sqlcmd = sqlcmd.Substring(0, sqlcmd.Length - ", ".Length) + " WHERE ";
pinfo.ForAll(x => sqlcmd += x.Name + " = " + x.GetValue(dbobject, null) + " AND ");
sqlcmd = sqlcmd.Substring(0, sqlcmd.Length - " AND ".Length);
}
public static void WriteLines <TSource>(
this ParallelQuery <TSource> source, Func <TSource, string> messageFactory = null)
{
if (messageFactory == null)
{
source.ForAll(value => Trace.WriteLine(value));
}
else
{
source.ForAll(value => Trace.WriteLine(messageFactory(value)));
}
}
private static void DoParallel()
{
ParallelQuery <string> pEnumerable = Paths().AsParallel();
pEnumerable.ForAll(ProcessFile); // простая PLINQ-операция с помощью метода расширения.
IEnumerable <string> p = pEnumerable.AsSequential(); // конвертируем параллельную последовательноть (!!) в обычный энумерабл.
}
public ActionResult <List <SeriesSearchResult> > StartsWith(string query, int limit = int.MaxValue)
{
query = query.ToLowerInvariant();
List <SeriesSearchResult> seriesList = new List <SeriesSearchResult>();
ConcurrentDictionary <SVR_AnimeSeries, string> tempSeries = new ConcurrentDictionary <SVR_AnimeSeries, string>();
ParallelQuery <SVR_AnimeSeries> allSeries = RepoFactory.AnimeSeries.GetAll()
.Where(a => a?.Contract?.AniDBAnime?.AniDBAnime != null &&
!a.Contract.AniDBAnime.Tags.Select(b => b.TagName)
.FindInEnumerable(User.GetHideCategories()))
.AsParallel();
#region Search_TitlesOnly
allSeries.ForAll(a => CheckTitlesStartsWith(a, query, ref tempSeries, limit));
Dictionary <SVR_AnimeSeries, string> series =
tempSeries.OrderBy(a => a.Value).ToDictionary(a => a.Key, a => a.Value);
foreach (KeyValuePair <SVR_AnimeSeries, string> ser in series)
{
seriesList.Add(new SeriesSearchResult(HttpContext, ser.Key, ser.Value, 0));
if (seriesList.Count >= limit)
{
break;
}
}
#endregion
return(seriesList);
}
private static void ExceptionHandlingInsideDelegate()
{
var range = ParallelEnumerable.Range(1, 20);
Func <int, int> selectDivision = (i) =>
{
try
{
return(i / (i - 10));
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Divide by zero exception for {0}", i);
return(-1);
}
};
ParallelQuery <int> query = range.Select(i => selectDivision(i)).WithDegreeOfParallelism(2);
try
{
query.ForAll(i => Console.WriteLine(i));
}
catch (AggregateException aggregateException)
{
foreach (var ex in aggregateException.InnerExceptions)
{
Console.WriteLine(ex.Message);
if (ex is DivideByZeroException)
{
Console.WriteLine("Attempt to divide by zero. Query stopped.");
}
}
}
}
public static void UpdateBoundingSpheres(ParallelQuery <Module> allModules)
{
allModules.ForAll(module =>
{
Module.UpdateFurthestPoints(module);
module.boundingSphere = Module.GetBoundingSphere(module, module.furthestA, module.furthestB, module.pose);
});
}
public static void ForAll(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
IntegerRangeSet seen = new IntegerRangeSet(0, count);
query.ForAll <int>(x => seen.Add(x));
seen.AssertComplete();
}
private LandmarkCollection(ParallelQuery <ILandmark> query)
{
var list = new List <ILandmark>();
query.ForAll(landmark => { lock (_syncLock) list.Add(landmark); });
_fastList = list.ToArray().ToFastList();
}
/// <summary>
/// <paramref name="source"/>를 모두 병렬로 실행하여, 결과를 <paramref name="target"/> 컬렉션에 요소로 추가한다.
/// </summary>
/// <typeparam name="TSource">요소의 수형</typeparam>
/// <param name="source">병렬 시퀀스</param>
/// <param name="target">공급자/소비자 패턴의 컬렉션</param>
public static void OutputToProducerConsumerCollection <TSource>(this ParallelQuery <TSource> source,
IProducerConsumerCollection <TSource> target)
{
source.ShouldNotBeNull("source");
target.ShouldNotBeNull("target");
// 병렬로 수행한 결과를 모두 컬렉션에 추가한다.
source.ForAll(item => target.TryAdd(item));
}
public static void UpdatePhysiologicalAge(ParallelQuery <Module> allModules, float dt)
{
allModules.ForAll(module =>
{
module.physiologicalAge += dt * PlantUtil.ChangeInPhysiologicalAge(module.root.v,
module.plant.plantConfig.vigorRootMin,
module.plant.plantConfig.vigorRootMax,
module.plant.plantConfig.growthRate);
});
}
static void Main(string[] args)
{
IEnumerable <int> numbers = Enumerable.Range(0, 20);
ParallelQuery <int> parallelResults = numbers
.AsParallel()
.Where(i => i % 2 == 0);
parallelResults.ForAll(i => Console.WriteLine(i));
}
/// <summary>
/// 扩展一个 forAll 方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="action"></param>
public static void ForAll <T>(this ParallelQuery <T> query, Action <T, int> action)
{
var index = 0;
query.ForAll((item) =>
{
var inner = Interlocked.Increment(ref index);
action(item, inner);
});
}
public static void OptimizeRotation(ParallelQuery <Module> allModules, int optimizationSteps, float eps)
{
var allSpheres = allModules.Select(module => module.boundingSphere);
for (int step = 0; step < optimizationSteps; step++)
{
// Find a better orientation
allModules.ForAll(module =>
{
float lowestFDistr = Module.ComputeFDistribution(module, module.pose, allSpheres);
Pose betterPose = module.pose;
for (int k = 0; k < 4; k++)
{
// This does euler angles (eps, 0, 0), (-eps, 0, 0), (0, 0, eps), (0, 0, -eps)
float rotAngle = eps;
if (k % 2 == 1)
{
rotAngle = -eps;
}
Quaternion rot = Quaternion.Euler(rotAngle, 0, 0);
if (k / 2 == 1)
{
rot = Quaternion.Euler(0, 0, rotAngle);
}
Pose nextPose = new Pose(module.pose.position, module.pose.rotation * rot); // according to https://answers.unity.com/questions/1353333/how-to-add-2-quaternions.html, multiplying in this order means that rot will be relative to the reference frame of module.orientation.rotation, so x axis is right, y axis is up, z axis is forward. We should double check this.
float fDistribution = Module.ComputeFDistribution(module, nextPose, allSpheres);
if (fDistribution < lowestFDistr)
{
betterPose = nextPose;
lowestFDistr = fDistribution;
}
}
module.nextPose = betterPose;
});
// Update orientation
allModules.ForAll(module =>
{
module.pose = module.nextPose;
});
}
}
internal static void QueryExpression()
{
int[] values = { 4, 3, 2, 1, 0, -1 };
ParallelQuery <int> source = values.AsParallel(); // Get source.
ParallelQuery <double> query = from int32 in source
where int32 > 0
orderby int32
select Math.Sqrt(int32); // Create query.
query.ForAll(result => Trace.WriteLine(result)); // Execute query.
}
internal static void QueryMethods()
{
int[] values = { 4, 3, 2, 1, 0, -1 };
ParallelQuery <int> source = values.AsParallel(); // Get source.
ParallelQuery <double> query = source
.Where(int32 => int32 > 0)
.OrderBy(int32 => int32)
.Select(int32 => Math.Sqrt(int32)); // Create query.
query.ForAll(result => Trace.WriteLine(result)); // Execute query.
}
private void CheckPosAgainstData(Point positionInData)
{
ParallelQuery <LineGraph> lineGraphs = null;
// There's going to be some threading issues with dynamic data, so this shouldn't be used on dynamic data
_dispatcher.Invoke(() =>
{
lineGraphs = _children?.OfType <LineGraph>().Where(lg => CursorFollowYGraph.GetSnapTo(lg) || CursorFollowXGraph.GetSnapTo(lg)).ToArray().AsParallel();
});
if (lineGraphs == null)
{
return;
}
ConcurrentDictionary <LineGraph, List <Point> > _filteredPointsByGraph = new ConcurrentDictionary <LineGraph, List <Point> >();
ConcurrentDictionary <LineGraph, double> interpolatedCursorPoints = new ConcurrentDictionary <LineGraph, double>();
lineGraphs.ForAll((lineGraph) =>
{
IEnumerable <Point> allPoints = null;
_dispatcher.Invoke(() =>
{
allPoints = lineGraph.GetPoints();
});
var filteredPoints = allPoints.ToList();
_filteredPointsByGraph[lineGraph] = filteredPoints;
});
lineGraphs.ForAll((lineGraph) =>
{
var filteredPoints = _filteredPointsByGraph[lineGraph];
var interpoloatedPoint = GetInterpolatedValue(filteredPoints, positionInData);
if (interpoloatedPoint.HasValue)
{
interpolatedCursorPoints[lineGraph] = interpoloatedPoint.Value;
}
});
OnNearestPointUpdated(interpolatedCursorPoints.Values.ToArray());
}
/// <summary>Runs the query and outputs its results into the target collection.</summary>
/// <typeparam name="TSource">Specifies the type of elements output from the query.</typeparam>
/// <param name="source">The source query.</param>
/// <param name="target">The target collection.</param>
public static void OutputToProducerConsumerCollection <TSource>(this ParallelQuery <TSource> source,
IProducerConsumerCollection <TSource> target)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
source.ForAll(item => target.TryAdd(item));
}
public static void ParallelLinqFuzzyMatch()
{
BenchPerformance.Time("Parallel Linq Fuzzy Match",
iterations: Data.Iterations, operation: () =>
{
ParallelQuery <string> matches = (from word in WordsToSearch.AsParallel()
from match in FuzzyMatch.JaroWinklerModule.bestMatch(Words, word)
select match.Word);
matches.ForAll(match =>
{
Log(match);
});
});
}
public static void UpdateVigor(ParallelQuery <Plant> allPlants)
{
allPlants.ForAll(plant =>
{
// trickle light from leaves down to root
Node.TrickleQ(plant.root.root);
// clamp vigior at vigor root max
plant.root.root.v = Min(plant.root.root.q, plant.plantConfig.vigorRootMax);
// trickle vigor from root out to leaves, according to extended Borchert-Honda model
Node.TrickleV(plant.root.root, plant.plantConfig.lambda);
Log("Vigor for plant is " + plant.root.root.v);
});
}
static void Main(string[] args)
{
ParallelQuery <Result> results = null;
results = from e in BuildData().AsParallel().WithDegreeOfParallelism(4)
where Func(e.Dept)
select new Result {
Name = e.Name,
ThreadID = Thread.CurrentThread.ManagedThreadId
};
Console.WriteLine("----- PLINQ Results -----");
results.ForAll((r) => Console.WriteLine("{0} found by thread {1}", r.Name, r.ThreadID));
}
internal static void Visualize <TSource>(
this ParallelQuery <TSource> source, Action <TSource> action, string span = Parallel, int category = 1)
{
using (Markers.EnterSpan(category, span))
{
MarkerSeries markerSeries = Markers.CreateMarkerSeries(span);
source.ForAll(value =>
{
using (markerSeries.EnterSpan(Thread.CurrentThread.ManagedThreadId, value.ToString()))
{
action(value);
}
});
}
}
static void Main(string[] args)
{
try
{
IEnumerable <int> numbers = Enumerable.Range(0, 20);
ParallelQuery <int> parallelResults = numbers
.AsParallel()
.Where(i => IsEven(i));
parallelResults.ForAll(i => Console.WriteLine(i));
}
catch (AggregateException ex)
{
Console.WriteLine($"There were {ex.InnerExceptions.Count} exceptions");
}
}
/// <summary>
/// Creates a single sorted dictionary containing the sum of the values grouped by cacheKey.
/// </summary>
/// <param name="values">The source enumerable</param>
/// <param name="autoPrecision">True is more accurate but less performant. False uses default double precision math.</param>
public static SortedDictionary <TKey, double> SumValuesOrdered <TKey>(this ParallelQuery <IDictionary <TKey, double> > values, bool autoPrecision = true)
where TKey : IComparable
{
if (values is null)
{
throw new NullReferenceException();
}
Contract.EndContractBlock();
var result = new ConcurrentDictionary <TKey, double>();
values.ForAll(autoPrecision ? result.AddValuesAccurate : result.AddValues);
return(new SortedDictionary <TKey, double>(result));
}
public static void ParallelLinqPartitionerFuzzyMatch()
{
BenchPerformance.Time("Parallel PLinq partitioner Fuzzy Match",
iterations: Data.Iterations, operation: () =>
{
var partitioner = Partitioner.Create(WordsToSearch, EnumerablePartitionerOptions.NoBuffering);
ParallelQuery <string> matches = (from word in WordsToSearch.AsParallel()
from match in FuzzyMatch.JaroWinklerModule.bestMatch(Words, word)
select match.Word);
matches.ForAll(match =>
{
Log(match);
});
});
}
public static void UpdateLight(ParallelQuery <Module> allModules)
{
var allSpheres = allModules.Select(module => module.boundingSphere);
allModules.ForAll(module =>
{
if (!module.isShed)
{
module.qFromSun = PlantUtil.CalculateLight(module.boundingSphere, allSpheres);
}
else
{
module.qFromSun = 0;
}
});
}
internal static void ParallelLinq()
{
int[] values = { 4, 3, 2, 1, 0, -1 };
ParallelQuery <int> source = values.AsParallel(); // Get source.
ParallelQuery <double> query =
from int32 in source
where int32 > 0
orderby int32
select Math.Sqrt(int32); // Define query.
// Equivalent to:
// ParallelQuery<double> query = source
// .Where(int32 => int32 > 0)
// .OrderBy(int32 => int32)
// .Select(int32 => Math.Sqrt(int32));
query.ForAll(result => Trace.WriteLine(result)); // Execute query.
}
/// <summary>Runs the query and outputs its results into the target collection.</summary>
/// <typeparam name="TSource">Specifies the type of elements output from the query.</typeparam>
/// <param name="source">The source query.</param>
/// <param name="target">The target collection.</param>
public static void OutputToProducerConsumerCollection <TSource>(
this ParallelQuery <TSource> source,
IProducerConsumerCollection <TSource> target)
{
// Validate arguments
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
// Store all results into the collection
source.ForAll(item => target.TryAdd(item));
}
public static void ShedBranches(ParallelQuery <Plant> allPlants, ParallelQuery <Module> allModules)
{
// Set as pruned
allModules.ForAll(module =>
{
// Branches are shed if vigor is less than vigorRootMin
if (module.root.v < module.plant.plantConfig.vigorRootMin)
{
//module.isShed = true;
}
});
// Remove all sheded modules from plants
allPlants.ForAll(plant =>
{
plant.modules = ParallelEnumerable.AsParallel(plant.modules).Where(module => !module.isShed).ToList();
});
}
public static void Do()
{
var sw = Stopwatch.StartNew();
var numbers = Enumerable.Range(0, 100);
try
{
// It will fail at 0, but will continue a bit longer...
ParallelQuery <int> parallelResult = numbers.AsParallel().Where(i => IsEven(i));
parallelResult.ForAll(e => Console.WriteLine(e));
}
catch (AggregateException e)
{
Console.WriteLine("exceptions: {0}", e.InnerExceptions.Count);
}
Console.ReadKey();
}
public static void RunExceptionTestForAll1()
{
int[] xx = new int[1024];
for (int i = 0; i < xx.Length; i++)
{
xx[i] = i;
}
ParallelQuery <int> q = xx.AsParallel().Select <int, int>(
delegate(int x) { if ((x % 250) == 249)
{
throw new Exception("Fail!");
}
return(x); });
Assert.Throws <AggregateException>(() =>
{
q.ForAll <int>(delegate(int x) { });
});
}