private async Task CallValidationService(ServiceCoreRequest value)
{
IValidationService proxy = proxyFactory.CreateServiceProxy <IValidationService>(
new Uri(
string.Concat(Context.CodePackageActivationContext.ApplicationName, "/Microsoft.IoT.ServiceFabric.Validation")),
new ServicePartitionKey(0L),
TargetReplicaSelector.PrimaryReplica);
using (MeasureTime measure = new MeasureTime())
{
ServiceResponse <ValidationServiceResponse> response = await proxy.ValidateMessage(value);
response.IsSuccess = response != null;
telemetry.TrackEvent(
"Core-Validation-Call",
new Dictionary <string, string>()
{
{ "Id", value.Id }
},
new Dictionary <string, double>()
{
{ "CoreElapsed", measure.Elapsed.TotalMilliseconds }
});
}
}
private TResult ExecuteNotifyingAction <TResult>(
Func <bool> canNotify,
Func <TResult> executeAction,
INamed action,
CommandType commandType)
{
if (!canNotify())
{
return(executeAction());
}
_depth++;
var(createBefore, createAfter, createError) = GetNotificationContentFactories <TResult>(action, commandType);
Observer.OnNext(new ActionNotification(action, _depth, createBefore(MeasureTime.Now)));
var(duration, result, exception) = MeasureTime.Measure(executeAction);
if (exception == null)
{
Observer.OnNext(new ActionNotification(action, _depth, createAfter(duration)));
_depth--;
return(result);
}
else
{
Observer.OnNext(new ActionNotification(action, _depth, createError(exception, duration)));
_depth--;
throw exception;
}
}
public static BitmapImage Init(Bitmap resultBmp, MeasureTime measure)
{
var stopwatch = Stopwatch.StartNew();
int[,] pixelArray = new int[resultBmp.Height, resultBmp.Width]; // one record on this array = one pixel
pixelArray = LowPerformance.SetOneZero(resultBmp, pixelArray);
deletion = 1;
int deletionFirst, deletionSecond;
while (deletion != 0)
{
deletion = 0;
pixelArray = LowPerformance.SetOneTwoThree(resultBmp, pixelArray);
(deletionFirst, pixelArray) = LowPerformance.FindAndDeleteFour(resultBmp, pixelArray);
(deletionSecond, pixelArray) = LowPerformance.DeletingTwoThree(resultBmp, pixelArray);
deletion = deletionFirst > deletionSecond ? deletionFirst : deletionSecond;
}
resultBmp = LowPerformance.SetImageAfterKMM(resultBmp, pixelArray);
measure.SumTimeElapsedMs(stopwatch.ElapsedMilliseconds);
return(BitmapConversion.Bitmap2BitmapImage(resultBmp));
}
public void conjuredItemsdegradeInQualityTwiceAsFastAsNormalItems()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new ConjuredItem {
Name = "Conjured", Sellin = 5, Quality = 50, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new ConjuredItem {
Name = "Conjured", Sellin = 4, Quality = 48
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public static BitmapImage LowPerformance(Bitmap tempBmp, Bitmap resultBmp, MeasureTime measure)
{
int threshold = OtsuValue(tempBmp); //calculate threshold by otsu value
var stopwatch = Stopwatch.StartNew(); //start measure time
int[] pixelValue = new int[tempBmp.Width + 1];
for (int y = 0; y < tempBmp.Height; y++)
{
for (int x = 0; x < tempBmp.Width; x++)
{
Color color = tempBmp.GetPixel(x, y);
pixelValue[x] = (color.R + color.G + color.B) / 3;
if (pixelValue[x] < threshold)
{
pixelValue[x] = 0;
}
else
{
pixelValue[x] = 255;
}
Color newColor = Color.FromArgb(pixelValue[x], pixelValue[x], pixelValue[x]);
resultBmp.SetPixel(x, y, newColor);
}
}
measure.TimeElapsedMs = stopwatch.ElapsedMilliseconds;
return(BitmapConversion.Bitmap2BitmapImage(resultBmp));
}
public void backStagePassesIncreaseBy3With5DaysOrLess()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new BackStagePass {
Name = "Backstage Passes", Sellin = 6, Quality = 40, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new BackStagePass {
Name = "Backstage Passes", Sellin = 5, Quality = 43
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void backStagePassesDropToZeroAfterConcert()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new BackStagePass {
Name = "Backstage Passes", Sellin = 1, Quality = 50, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new BackStagePass {
Name = "Backstage Passes", Sellin = 0, Quality = 0
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void qualityOfStandardItemNeverMoreThan50WhenSetFirstTime()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new StandardItem {
Name = "Normal Item", Sellin = 2, Quality = 51, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new StandardItem {
Name = "Normal Item", Sellin = 1, Quality = 50
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void sulfurasNeverDecreasesInQuality()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new LegendaryItem {
Name = "Sulfuras", Sellin = 2, Quality = 50, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new LegendaryItem {
Name = "Sulfuras", Sellin = 2, Quality = 50
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void itemWithNegativeQualityIsSetToZero()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new StandardItem {
Name = "Normal Item", Sellin = 1, Quality = -1, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new StandardItem {
Name = "Normal Item", Sellin = 0, Quality = 0
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void agedBrieIncreasesInQualityWithAge()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new AgedBrie {
Name = "Aged Brie", Sellin = 2, Quality = 2, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new AgedBrie {
Name = "Aged Brie", Sellin = 1, Quality = 3
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void standardItemSellinAndQualityDecreaseOnDayPassedAndSellByPassed()
{
// Arrange
var timer = new MeasureTime();
var currentStock = new List <IStockable>();
currentStock.Add(new StandardItem {
Name = "Normal Item", Sellin = 1, Quality = 2, Timer = timer
});
var expectedStockAfter1Day = new List <IStockable>();
expectedStockAfter1Day.Add(new StandardItem {
Name = "Normal Item", Sellin = 0, Quality = 0
});
var stockManager = new ManageStock();
stockManager.AddStock(currentStock);
// Act
timer.advanceDay();
var finalStock = stockManager.GetStock();
// Assert
CollectionAssert.AreEqual(finalStock, expectedStockAfter1Day, new StockComparer());
}
public void Enumerate(IEnumerable <Assembly> listAssemblySource)
{
var measure1 = new MeasureTime();
EnumerateList(listAssemblySource);
EnumerateScheduled();
var t1 = measure1.Calculate();
var measure2 = new MeasureTime();
foreach (var pair in _assembliesToLoad)
{
try
{
_callbackAfterLoad(pair.Value);
}
catch { }
}
var t2 = measure2.Calculate();
if (_loggingOptions.HasFlag(LibraryEnumeratorFactory.eLoggingOptions.EnumerationSummary))
{
Debug.WriteLine("{2}EnumerationSummarySource: libs - {0}ms, callback - {1}ms", t1.TotalMilliseconds, t2.TotalMilliseconds, NameForLogging);
}
}
private void GeneratePrecompiledView(string _relPath, bool logOnlyErrors = true)
{
var measure2 = new MeasureTime();
var message = "";
var success = false;
try
{
var id = System.Threading.Thread.CurrentThread.ManagedThreadId;
measure2.Start();
var type = System.Web.Compilation.BuildManager.GetCompiledType(_relPath);
success = true;
}
catch (Exception ex)
{
var exx = ex.GetLowLevelException();
message = ", err: " + exx.Message;
}
finally
{
if (!logOnlyErrors || (logOnlyErrors && !string.IsNullOrEmpty(message)))
{
Debug.WriteLineNoLog("Precompiling '{0}' is {1}, time {2:D}ms {3}", _relPath, success, measure2, message);
}
}
}
public void Analyze3()
{
using (var measureTime = new MeasureTime()) {
var count = transform.childCount;
var ruleSpace = ruleSpaceDesc.Create(stateCount);
var packer = new Packer(stateCount);
var p = Enumerable.Range(0, count)
.Select(_ => new Rule(packer, ruleSpace.GenerateRandomFullTable(), 2))
.Select(rule => new Emulator(rule, timeSize, spaceSize, startFill, borderFill, new Random(seed)))
.Select(emulator => emulator.EmulateInPlace())
.ToArray();
}
}
public static void Main()
{
string rnd_str = RandomString(500000);
Regex regex = new Regex("a|c|e|g|i|k", RegexOptions.Compiled);
TimeSpan ts1 = MeasureTime.Run(() => regex.Replace(rnd_str, "!!!"), 10);
Console.WriteLine("Regex time: {0:hh\\:mm\\:ss\\:fff}", ts1);
StringBuilder sb_str = new StringBuilder(rnd_str);
TimeSpan ts2 = MeasureTime.Run(() => sb_str.Replace("a", "").Replace("c", "").Replace("e", "").Replace("g", "").Replace("i", "").Replace("k", ""), 10);
Console.WriteLine("StringBuilder time: {0:hh\\:mm\\:ss\\:fff}", ts2);
TimeSpan ts3 = MeasureTime.Run(() => rnd_str.Replace("a", "").Replace("c", "").Replace("e", "").Replace("g", "").Replace("i", "").Replace("k", ""), 10);
Console.WriteLine("String time: {0:hh\\:mm\\:ss\\:fff}", ts3);
}
public byte[] GetBytes()
{
List <byte> header = new List <byte>();
List <byte> body = new List <byte>();
List <byte> arrData = new List <byte>();
header.AddRange(Utils.GetBytes(CommConst.CMD_TDAT));
header.AddRange(Utils.GetBytes(CommConst.WORK_CODE));
header.AddRange(Utils.GetBytes(CommConst.CHIM_CODE));
header.AddRange(BitConverter.GetBytes(Length)); // 전체길이
header.AddRange(Utils.GetBytes(MeasureTime.ToString("yyMMddHHmm")));
body.AddRange(BitConverter.GetBytes(Convert.ToUInt16(ListPreFc.Count)));
foreach (Facility preFc in ListPreFc)
{
body.AddRange(preFc.GetBytes());
}
body.AddRange(BitConverter.GetBytes(Convert.ToUInt16(ListDisFc.Count)));
foreach (Facility disFc in ListDisFc)
{
body.AddRange(disFc.GetBytes());
}
Length = header.Count + body.Count + 4; // Tailer 포함
byte[] bCnt = BitConverter.GetBytes(Length);
for (int i = 0; i < 4; i++)
{
header[i + 11] = bCnt[i];
}
// arrData Tailer에 chksum을 추가
arrData.AddRange(header);
arrData.AddRange(body);
byte[] data = arrData.OfType <byte>().ToArray();
Crc16Ccitt crc = new Crc16Ccitt(InitialCrcValue.Zeros);
int chksum = crc.ComputeChecksum(data);
arrData.AddRange(BitConverter.GetBytes(chksum));
data = arrData.OfType <byte>().ToArray();
return(data);
}
public void Emulate()
{
using (var measureTime = new MeasureTime()) {
var random = useSeed ? new Random(seed) : new Random();
var packer = new Packer(stateCount);
var rule = new Rule(packer, BigInteger.Parse(ruleCode), tablePackN);
measureTime.Mark("After rule inst");
if (spacetime == null || spacetime.Length != timeSize || spacetime[0].spaceSize != spaceSize)
{
spacetime = new PackedSpace[timeSize];
for (var t = 0; t < spacetime.Length; t++)
{
spacetime[t] = new PackedSpace(packer, spaceSize);
}
}
var emulator = new Emulator(
rule, timeSize, spaceSize, startFill, borderFill, random);
measureTime.Mark("After raw spacetime creation");
emulator.Emulate(spacetime);
measureTime.Mark("After emulate itself");
var material = GetComponent <Renderer>().material;
material.SetInt("_TimeSize", timeSize);
material.SetInt("_SpaceSize", spaceSize);
var spaceSizePacked = spacetime[0].packedSize;
var bufferSize = timeSize * spaceSizePacked;
if (buffer is null || buffer.count != bufferSize)
{
buffer?.Dispose();
buffer = new ComputeBuffer(bufferSize, sizeof(UInt32));
}
for (var t = 0; t < spacetime.Length; t++)
{
buffer.SetData(spacetime[t].packed, 0, t * spaceSizePacked, spaceSizePacked);
}
material.SetBuffer("_SpacetimePacked", buffer);
measureTime.Mark("After shader");
}
}
public void Test()
{
if (shader is null || shader.shader != shaderRef)
{
shader?.DisposeBuffers();
shader = new EmulateComputeShader(shaderRef);
}
using (var measureTime = new MeasureTime()) {
// if (rules == null) {
// UpdateRules();
// measureTime.Mark("After UpdateRules");
// }
shader.Emulate(stateCount, spaceSize, timeSize, randSeed, rules, inPlace);
measureTime.Mark("After Dispatch");
var fs = new float[parallelRules];
var packer = rules[0].packer;
var timeSize1 = inPlace ? 2 : timeSize;
var packedSpaceSize = packer.GetPackedSize(spaceSize);
var layerSize = packedSpaceSize * timeSize1;
for (var i = 0; i < parallelRules; i++)
{
var space = new PackedSpace(packer, spaceSize);
shader.spacetimePackedBuffer.GetData(
space.packed,
0,
layerSize * i + packedSpaceSize * (timeSize1 - 1),
packedSpaceSize);
fs[i] = RuleSpacetimeAnalyzer.RenderAnalyze(packer, spaceSize, space.Convolute(), patternLength);
}
measureTime.Mark("After Analyze");
SetDisplays(rules.Select(rule => rule.code.ToString()).ToArray(), fs);
measureTime.Mark("After SetDisplays");
}
}
private void Execute()
{
async Task InitializeLP() //initialize methods that use Get/Set Pixel
{
MeasureTime measureLP = new MeasureTime();
Bitmaps.BinarizeLPImage = BitmapConversion.CreateNonIndexedImage(new Bitmap(Bitmaps.Filepath));
Bitmaps.BinarizeLPImageView = await Task.Run(() => Binarization.LowPerformance(new Bitmap(Bitmaps.Filepath), Bitmaps.BinarizeLPImage, measureLP));
Bitmaps.KMMLP = await Task.Run(() => KMMLowPerformanceMain.Init(Bitmaps.BinarizeLPImage, measureLP));
Bitmaps.TimeElapsedLP = measureLP.TimeElapsedMs;
}
async Task InitializeHP() //initialize methods with lockbits, marshall copy
{
MeasureTime measureHP = new MeasureTime();
Bitmaps.BinarizeHPImage = await Task.Run(() => Binarization.HighPerformance(new Bitmap(Bitmaps.Filepath), measureHP));
Bitmaps.BinarizeHPImageView = BitmapConversion.Bitmap2BitmapImage(Bitmaps.BinarizeHPImage);
Bitmaps.KMMHP = await Task.Run(() => BitmapConversion.Bitmap2BitmapImage(KMMHighPerformanceMain.Init(Bitmaps.BinarizeHPImage, measureHP)));
Bitmaps.TimeElapsedHP = measureHP.TimeElapsedMs;
Bitmaps.TimeElapsedHPTicks = measureHP.TimeElapsedTicks;
}
try
{
var task1 = Task.Run(() => InitializeLP());
var task2 = Task.Run(() => InitializeHP());
Task.WaitAll(task1, task2);
}
catch (Exception ex)
{
if (ex is ArgumentNullException || ex is AggregateException)
{
System.Windows.MessageBox.Show("There is no image to Apply KMM");
}
}
}
public static Bitmap HighPerformance(Bitmap resultBmp, MeasureTime measure)
{
int threshold = OtsuValue(resultBmp);
var stopwatch = Stopwatch.StartNew();
int pixelBPP = Image.GetPixelFormatSize(resultBmp.PixelFormat) / 8;
unsafe
{
BitmapData bmpData = resultBmp.LockBits(new Rectangle(0, 0, resultBmp.Width, resultBmp.Height), ImageLockMode.ReadWrite, resultBmp.PixelFormat);
byte *ptr = (byte *)bmpData.Scan0; //addres of first line
int height = resultBmp.Height;
int width = resultBmp.Width * pixelBPP;
Parallel.For(0, height, y =>
{
byte *offset = ptr + (y * bmpData.Stride); //set row
for (int x = 0; x < width; x = x + pixelBPP)
{
byte value = (offset[x] + offset[x + 1] + offset[x + 2]) / 3 > threshold ? Byte.MaxValue : Byte.MinValue;
offset[x] = value;
offset[x + 1] = value;
offset[x + 2] = value;
if (pixelBPP == 4)
{
offset[x + 3] = 255;
}
}
});
resultBmp.UnlockBits(bmpData);
}
stopwatch.Stop();
measure.TimeElapsedMs = stopwatch.ElapsedMilliseconds;
measure.TimeElapsedTicks = stopwatch.ElapsedTicks;
return(resultBmp);
}
public static void Main()
{
string rnd_str = RandomString(500000);
Regex regex = new Regex("a|c|e|g|i|k", RegexOptions.Compiled);
TimeSpan ts1 = MeasureTime.Run(() => regex.Replace(rnd_str, "!!!"), 10);
Console.WriteLine("Regex time: {0:hh\\:mm\\:ss\\:fff}", ts1);
StringBuilder sb_str = new StringBuilder(rnd_str);
TimeSpan ts2 = MeasureTime.Run(() => sb_str.Replace("a", "").Replace("c", "").Replace("e", "").Replace("g", "").Replace("i", "").Replace("k", ""), 10);
Console.WriteLine("StringBuilder time: {0:hh\\:mm\\:ss\\:fff}", ts2);
TimeSpan ts3 = MeasureTime.Run(() => rnd_str.Replace("a", "").Replace("c", "").Replace("e", "").Replace("g", "").Replace("i", "").Replace("k", ""), 10);
Console.WriteLine("String time: {0:hh\\:mm\\:ss\\:fff}", ts3);
char[] ch_arr = { 'a', 'c', 'e', 'g', 'i', 'k' };
TimeSpan ts4 = MeasureTime.Run(() => new String((from c in rnd_str where !ch_arr.Contains(c) select c).ToArray()), 10);
Console.WriteLine("LINQ time: {0:hh\\:mm\\:ss\\:fff}", ts4);
}
public static unsafe Bitmap Init(Bitmap resultBmp, MeasureTime measure)
{
var stopwatch = Stopwatch.StartNew();
resultBmp = BitmapConversion.Create8bppGreyscaleImage(resultBmp);
BitmapData bmpData = resultBmp.LockBits(new Rectangle(0, 0, resultBmp.Width, resultBmp.Height),
ImageLockMode.ReadWrite,
resultBmp.PixelFormat
);
int bytes = bmpData.Stride * resultBmp.Height;
byte[] pixels = new byte[bytes];
Marshal.Copy(bmpData.Scan0, pixels, 0, bytes);
int height = resultBmp.Height;
int width = resultBmp.Width;
int deletion = 1;
int deletionFirst, deletionSecond;
while (deletion != 0)
{
deletion = 0;
pixels = HighPerformance.SetOneTwoThree(pixels, bmpData.Stride, height, width);
(deletionFirst, pixels) = HighPerformance.FindAndDeleteFour(pixels, bmpData.Stride, height, width, deletion);
(deletionSecond, pixels) = HighPerformance.DeletingTwoThree(pixels, bmpData.Stride, height, width, deletion);
deletion = deletionFirst > deletionSecond ? deletionFirst : deletionSecond;
}
Marshal.Copy(pixels, 0, bmpData.Scan0, bytes);
resultBmp.UnlockBits(bmpData);
stopwatch.Stop();
measure.SumTimeElapsedMs(stopwatch.ElapsedMilliseconds);
measure.SumTimeElapsedTicks(stopwatch.ElapsedTicks);
return(resultBmp);
}
/// <summary>
/// </summary>
public static bool Startup()
{
try
{
lock (SyncRoot)
{
if (!_isInitialized)
{
var measure = new MeasureTime();
var entryAssembly = Assembly.GetEntryAssembly();
Debug.WriteLine("StartupFactory={0}", entryAssembly?.FullName);
if (IsDeveloperRuntime())
{
Debug.WriteLine("StartupEntryAssembly=null. Считаем, что загрузка произошла в VisualStudio и прекращаем привязку. Далее часть отладочной информации.");
_isInitialized = true;
return(false);
}
var loadedAssemblies = AppDomain.
CurrentDomain.GetAssemblies().
Where(x => Reflection.LibraryEnumerator.FilterDevelopmentRuntime(x.FullName, null));
PrepareAssembly(loadedAssemblies.ToArray());
Debug.WriteLine("Startup load assemblies ends with {0}ms", measure.Calculate().TotalMilliseconds);
AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
_isInitialized = true;
}
}
}
catch { }
return(true);
}
/// <summary>
/// Осуществляет перечисление сборок в папке <see cref="LibraryDirectory"/>.
/// </summary>
/// <param name="callbackAfterLoad">Если задано, то вызывается для сборки, если callbackBeforeLoad не задано или возвратило true.</param>
/// <param name="callbackBeforeLoad">Если задано, то вызывается для каждой найденной сборки. Если возвращает false, то обработка этоЙ сборки прекращается.</param>
/// <param name="enumerateAttrs">Указывает, какие библиотеки следует включить в перечисление.</param>
/// <param name="nameForLogging"></param>
/// <param name="tasksAllowed"></param>
public static IEnumerable <TResult> Enumerate <TResult>(Func <Assembly, TResult> callbackAfterLoad, Func <string, bool> callbackBeforeLoad = null, EnumerateAttrs enumerateAttrs = EnumerateAttrs.ExcludeMicrosoft | EnumerateAttrs.ExcludeSystem, string nameForLogging = null, bool tasksAllowed = false)
{
var results = new HashSet <TResult>();
var measure = new MeasureTime();
try
{
Action <Assembly> action = (a) =>
{
var result = callbackAfterLoad(a);
if (result != null)
{
results.Add(result);
}
};
var dddddd = new Reflection.LibraryEnumerator(action, callbackBeforeLoad, enumerateAttrs, GlobalAssemblyFilter, LoggingOptions, nameForLogging, tasksAllowed);
dddddd.Enumerate();
}
catch (Exception)
{
}
finally
{
if (!_isFirstFullEnumeration)
{
_isFirstFullEnumeration = true;
if (LoggingOptions.HasFlag(eLoggingOptions.EnumerationSummaryFirstRun))
{
Debug.WriteLine("LibraryEnumeratorFactory.Enumerate: First enumeration ends with {0}ms", measure.Calculate().TotalMilliseconds);
}
}
}
return(results);
}
private TResult ExecuteNotifyingAction <TResult>(Func <bool> canNotify, Func <TResult> executeAction, INamed action)
{
if (!canNotify())
{
return(executeAction());
}
_depth++;
Observer.OnNext(new ActionNotification(action, _depth, new BeforeActionNotificationContent()));
try
{
var result = MeasureTime.Measure(executeAction);
Observer.OnNext(new ActionNotification(action, _depth, new AfterActionNotificationContent(result.Item1)));
return(result.Item2);
}
catch (Exception ex)
{
Observer.OnNext(new ActionNotification(action, _depth, new ExecutionErrorNotificationContent(ex)));
throw;
}
finally
{
_depth--;
}
}
public void Analyze()
{
using (var watch = new MeasureTime()) {
var targets = GetComponentsInChildren <RuleSpacetime>();
watch.Mark("After get targets");
foreach (var target in targets)
{
if (randomizeRules)
{
var converter = target.GetComponent <RuleCodeConverter>();
converter.Randomize();
}
}
watch.Mark("After Randomize");
foreach (var target in targets)
{
target.Emulate();
}
watch.Mark("After Emulate");
foreach (var target in targets)
{
var analyzer = target.GetComponent <RuleSpacetimeAnalyzer>();
analyzer.Analyze();
}
watch.Mark("After Analyze");
targets
.OrderBy(t => t.GetComponent <RuleSpacetimeAnalyzer>().f)
.Do((target, i) => {
target.transform.parent.localPosition =
midOffset * i
+ fOffset * target.GetComponent <RuleSpacetimeAnalyzer>().f;
})
.ToArray();
watch.Mark("After sort and position");
}
}
/// <summary>
/// Осуществляет перечисление сборок в папке <see cref="LibraryDirectory"/>.
/// </summary>
/// <param name="callbackAfterLoad">Если задано, то вызывается для сборки, если callbackBeforeLoad не задано или возвратило true.</param>
/// <param name="callbackBeforeLoad">Если задано, то вызывается для каждой найденной сборки. Если возвращает false, то обработка этоЙ сборки прекращается.</param>
/// <param name="enumerateAttrs">Указывает, какие библиотеки следует включить в перечисление.</param>
/// <param name="nameForLogging"></param>
/// <param name="tasksAllowed"></param>
public static void Enumerate(Action <Assembly> callbackAfterLoad, Func <string, bool> callbackBeforeLoad = null, EnumerateAttrs enumerateAttrs = EnumerateAttrs.ExcludeMicrosoft | EnumerateAttrs.ExcludeSystem, string nameForLogging = null, bool tasksAllowed = false)
{
var measure = new MeasureTime();
try
{
var dddddd = new Reflection.LibraryEnumerator(callbackAfterLoad, callbackBeforeLoad, enumerateAttrs, GlobalAssemblyFilter, LoggingOptions, nameForLogging, tasksAllowed);
dddddd.Enumerate();
}
catch (Exception)
{
}
finally
{
if (!_isFirstFullEnumeration)
{
_isFirstFullEnumeration = true;
if (LoggingOptions.HasFlag(eLoggingOptions.EnumerationSummaryFirstRun))
{
Debug.WriteLine("LibraryEnumeratorFactory.Enumerate: First enumeration ends with {0}ms", measure.Calculate().TotalMilliseconds);
}
}
}
}
void IMessagingServiceInternal.PrepareOutcoming(TimeSpan executeInterval)
{
if (AppCore.GetState() != CoreComponentState.Started)
{
return;
}
var type = GetType();
if (!_executingFlags.TryLock(TasksOutcomingSend))
{
return;
}
_executingFlags.ReleaseLock(nameof(RegisterOutcomingMessage));
int messagesAll = 0;
int messagesSent = 0;
int messagesErrors = 0;
try
{
using (var db = new DB.DataContext())
using (var scope = db.CreateScope(TransactionScopeOption.Suppress)) // Здесь Suppress вместо RequiresNew, т.к. весь процесс отправки занимает много времени и блокировать таблицу нельзя.
{
var timeEnd = DateTimeOffset.Now.Add(executeInterval);
while (DateTimeOffset.Now < timeEnd)
{
var messages = GetMessages(db, false, 100, _outcomingQueueInfo);
if (messages.IsNullOrEmpty())
{
break;
}
messagesAll += messages.Count;
OnBeforeExecuteOutcoming(messagesAll);
var processedMessages = new List <IntermediateStateMessage <TMessage> >();
var time = new MeasureTime();
foreach (var intermediateMessage in messages)
{
if (DateTimeOffset.Now >= timeEnd)
{
break;
}
if (intermediateMessage.MessageSource.StateType == DB.MessageStateType.Error)
{
processedMessages.Add(intermediateMessage);
continue;
}
var components = GetComponents().
OfType <OutcomingMessageSender <TMessage> >().
Select(x => new
{
Component = x,
IdTypeComponent = ItemTypeFactory.GetItemType(x.GetType())?.IdItemType
}).
OrderBy(x => ((IPoolObjectOrdered)x.Component).OrderInPool).
ToList();
if (intermediateMessage.MessageSource.IdTypeComponent.HasValue)
{
components = components.Where(x => x.IdTypeComponent.HasValue && x.IdTypeComponent == intermediateMessage.MessageSource.IdTypeComponent).ToList();
}
foreach (var componentInfo in components)
{
try
{
var component = componentInfo.Component;
var messageInfo = new MessageInfo <TMessage>(intermediateMessage);
var componentResult = component.OnSend(messageInfo, this);
if (componentResult != null)
{
intermediateMessage.MessageSource.DateChange = DateTime.Now;
switch (componentResult.StateType)
{
case MessageStateType.Completed:
intermediateMessage.MessageSource.StateType = DB.MessageStateType.Complete;
intermediateMessage.MessageSource.State = null;
intermediateMessage.MessageSource.IdTypeComponent = null;
intermediateMessage.MessageSource.DateDelayed = null;
break;
case MessageStateType.Delayed:
intermediateMessage.MessageSource.StateType = DB.MessageStateType.NotProcessed;
intermediateMessage.MessageSource.State = componentResult.State;
intermediateMessage.MessageSource.IdTypeComponent = null;
intermediateMessage.MessageSource.DateDelayed = componentResult.DateDelayed;
break;
case MessageStateType.Repeat:
intermediateMessage.MessageSource.StateType = DB.MessageStateType.Repeat;
intermediateMessage.MessageSource.State = componentResult.State;
intermediateMessage.MessageSource.IdTypeComponent = componentInfo.IdTypeComponent;
intermediateMessage.MessageSource.DateDelayed = componentResult.DateDelayed;
break;
case MessageStateType.Error:
intermediateMessage.MessageSource.StateType = DB.MessageStateType.Error;
intermediateMessage.MessageSource.State = componentResult.State;
intermediateMessage.MessageSource.IdTypeComponent = null;
intermediateMessage.MessageSource.DateDelayed = componentResult.DateDelayed;
break;
}
messagesSent++;
processedMessages.Add(intermediateMessage);
break;
}
}
catch
{
messagesErrors++;
continue;
}
}
_outcomingQueueInfo.IdQueueCurrent = intermediateMessage.MessageSource.IdQueue;
if (time.Calculate(false).TotalSeconds >= 3)
{
db.SaveChanges();
processedMessages.Clear();
time.Start();
}
}
if (processedMessages.Count > 0)
{
db.SaveChanges();
}
}
db.SaveChanges();
scope.Complete();
}
}
catch (Exception ex)
{
this.RegisterServiceState(ServiceStatus.RunningWithErrors, $"Сообщений получено для отправки - {messagesAll}. Отправлено - {messagesSent}. Ошибки отправки - {messagesErrors}.", ex);
}
finally
{
_executingFlags.ReleaseLock(TasksOutcomingSend);
}
}
public void GeneratePrecompiled(bool logOnlyErrors = true)
{
logOnlyErrors = true;
var filesList = new List <string>();
var field = typeof(FileInfo).GetField("FullPath", BindingFlags.Instance | BindingFlags.NonPublic);
var paths = SourceDevelopmentPathList.Merge(SourcePathList);
foreach (var path in paths)
{
if (!Directory.Exists(path))
{
continue;
}
var fileList = new DirectoryInfo(path).GetFiles("*.cshtml", SearchOption.AllDirectories);
foreach (var file in fileList)
{
try
{
var filepath = "";
if (field != null)
{
filepath = (string)field.GetValue(file);
}
else
{
filepath = file.FullName;
}
if (filepath.ToLower().Contains("symlink"))
{
continue;
}
if (!filesList.Contains(filepath) && !filepath.Contains("\\bin\\"))
{
filesList.Add(filepath);
}
}
catch { }
}
}
var measure = new MeasureTime();
try
{
foreach (var file in filesList)
{
var relPath = TranslateFullPathTo(file);
if (Path.GetFileName(relPath).ToLower().StartsWith("base"))
{
continue;
}
GeneratePrecompiledView(relPath, logOnlyErrors);
}
Debug.WriteLine("Precompiling Background {0} files, time {1:D}ms. See detailed errors in console", filesList.Count, measure);
}
catch (Exception ex) { Debug.WriteLine("Precompiling Background {0} files, time {1:D}ms with error: {2}. See detailed errors in console", filesList.Count, measure, ex.Message); }
//Task.Factory.StartNew(() =>
//{
// var measure = new MeasureTime();
// try
// {
// var tasks = new List<Task>();
// foreach (var file in filesList)
// {
// var relPath = TranslateFullPathTo(file);
// if (Path.GetFileName(relPath).ToLower().StartsWith("base"))
// continue;
// tasks.Add(Task.Factory.StartNew((state) =>
// {
// var _relPath = state as string;
// GeneratePrecompiledView(_relPath, logOnlyErrors);
// }, relPath, TaskCreationOptions.AttachedToParent));
// }
// Task.WaitAll(tasks.ToArray());
// Debug.WriteLine("Precompiling Background {0} files, time {1:D}ms", filesList.Count, measure);
// }
// catch (Exception ex) { Debug.WriteLine("Precompiling Background {0} files, time {1:D}ms with error: {2}", filesList.Count, measure, ex.Message); }
//}, TaskCreationOptions.LongRunning);
}
