/// <summary> /// Returns current BitmaapSource scaled below the given dimensions /// WILL NOT store if it has to build it on the fly /// </summary> public BitmapSource BitmapSourceScaledToBelow(int width, int height) { try { ByteArrayBitmap bab; if (this._bitmap != null) { bab = this._bitmap; } else { bab = TryToDecodeEncodedData(); if (bab == null) { return(null); } } return(bab.ToBitmapSourceScaledToBelow(width, height)); } catch (Exception er) { DebugMessageLogger.LogError(er); return(null); } }
public bool ZipAsync(string[] files, string outputFile, ZipAsyncCallback callback) { try { StringBuilder sb = new StringBuilder(); sb.AppendFormat("a -tzip \"{0}\"", outputFile); foreach (string file in files) { sb.AppendFormat(" \"{0}\"", file); } _ZipAsyncCallback = callback; DebugMessageLogger.LogEventLevel("Running: {0} {1}", 0, exeLoc, sb.ToString()); ProcessStartInfo info = new ProcessStartInfo(exeLoc, sb.ToString()); info.RedirectStandardOutput = true; info.CreateNoWindow = true; info.UseShellExecute = false; _ZipProcess = Process.Start(info); _reader = _ZipProcess.StandardOutput; _ZipAsyncProcessCommandlineReader = new Thread(new ThreadStart(ProcessOutputReader)); _ZipAsyncProcessCommandlineReader.Name = "Z7a.exe process commandline reader"; _ZipAsyncProcessCommandlineReader.Start(); return(true); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(false); }
private ByteArrayBitmap TryToDecodeEncodedData() { try { if (this.EncodedData == null) { return(null); } BitmapDecoder decoder; using (MemoryStream memoryStream = new MemoryStream(this.EncodedData)) decoder = BitmapDecoder.Create(memoryStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); BitmapFrame bitmapFrame = decoder.Frames[0]; return(new ByteArrayBitmap(bitmapFrame)); string[] mimeTypes = decoder.CodecInfo.MimeTypes.Split(','); if (mimeTypes.Length > 0) { this.EncodedDataContentType = new ContentType(mimeTypes[0]); } // log access for drop on age calc _lastDecodedDataAccess = DateTime.Now; TrySetWidthHeight(); } catch (Exception ee) { DebugMessageLogger.LogError(ee); return(null); } }
/// <summary> /// immediately logs exception, including DateTime.Now timestamp, if the level of logging is high enough /// </summary> /// <param name="e"></param> public static void LogError(Exception e, int logLevel) { if (logLevel <= ErrorLogLevel) { DebugMessageLogger.LogError(e, null, logLevel); } }
public static void LogMemAndLinenumber() { StackFrame st = new StackFrame(1, true); float privateMB = Process.GetCurrentProcess().PrivateMemorySize64 / 1000000f; DebugMessageLogger.LogEvent("Memory Use {0}mb at {1}", privateMB, st); }
public static int CountJpegsFrames(string filename) { int count = 0; try { int batchsize = 1000; int linelimit = 0; byte?[] jpegHeaderpattern = new byte?[] { 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2F, 0x6A, 0x70, 0x65, 0x67 }; //new byte?[] { 0x43, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x2D, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x3A }; //new byte?[] { 0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46 }; //new byte?[]{0x2D, 0x2D, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x61, 0x72, 0x79}; //new byte?[] { 0xFF, null, 0xFF, null }; byte[] buffer = new byte[batchsize]; using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read))) { while (br.BaseStream.Length > br.BaseStream.Position) { int datastart = ByteArrayUtils.IndexOf(buffer, jpegHeaderpattern, linelimit, batchsize); if (datastart != -1) { count++; } Array.Copy(br.ReadBytes(batchsize), buffer, batchsize); } } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(count); }
public bool ZipFolder(string folder, string outputFile) { try { StringBuilder sb = new StringBuilder(); sb.AppendFormat("a -tzip \"{0}\"", outputFile); sb.AppendFormat(" \"{0}\"", folder); //_ZipAsyncCallback = callback; DebugMessageLogger.LogEventLevel("Running: {0} {1}", 0, exeLoc, sb.ToString()); ProcessStartInfo info = new ProcessStartInfo(exeLoc, sb.ToString()); info.RedirectStandardOutput = true; info.CreateNoWindow = true; info.UseShellExecute = false; _ZipProcess = Process.Start(info); _reader = _ZipProcess.StandardOutput; ProcessOutputReader(); return(true); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(false); }
private void ProcessOutputReader() { StringBuilder sb = new StringBuilder(); try { while (_continueReading && !_reader.EndOfStream) { try { char[] block = new char[100]; _reader.ReadBlock(block, 0, 100); string currentblock = new string(block); //string line = previousblock + currentblock; if (currentblock != null) { sb.AppendFormat("{0}", currentblock); } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } } } catch (Exception eee) { DebugMessageLogger.LogError(eee); } if (_ZipAsyncCallback != null) { _ZipAsyncCallback(sb.ToString()); } }
public void Save(string path, System.Drawing.Imaging.ImageFormat format) { try { using (MemoryStream ms = new MemoryStream(this._CompressedData)) { Bitmap bmp = new Bitmap(ms); bmp.Save(path, format); //Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); //System.Drawing.Imaging.BitmapData bmpData = // bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, // bmp.PixelFormat); //// Get the address of the first line. //IntPtr ptr = bmpData.Scan0; //// Declare an array to hold the bytes of the bitmap. //int bytes = bmpData.Stride * bmp.Height; //System.Runtime.InteropServices.Marshal.Copy(Data, 0, ptr, bytes); //// Unlock the bits. //bmp.UnlockBits(bmpData); } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
public static string InsertLinebreaks(string text, int lineCharLength, char[] breakat) { try { if (String.IsNullOrEmpty(text)) { return(""); } if (text.Length <= lineCharLength) { return(text); } int searchBack = 5; int searchForward = 5; List <int> breakPos = new List <int>(); for (int i = lineCharLength; i < text.Length; i += lineCharLength) { //word wrap code. int pos = text.IndexOfAny(breakat, i - searchBack, searchForward); if (pos == -1) { pos = i; } breakPos.Add(pos); } breakPos.Add(text.Length); string[] lines = new string[breakPos.Count]; int prev = 0; for (int i = 0; i < breakPos.Count; i++) { lines[i] = text.Substring(prev, breakPos[i] - prev).TrimStart(' ', '\t'); prev = breakPos[i]; } string output = lines[0]; if (lines.Length > 1) { for (int i = 1; i < lines.Length; i++) { output += "\n" + lines[i]; } } return(output); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(text); }
/// <summary> /// This method looks for the index at the end of the frame packet. This should be in the format DateTime.Int /// following a final "--videoboundary" /// </summary> /// <param name="buffer"></param> /// <param name="stampA"></param> /// <param name="stampB"></param> /// <returns></returns> public static List <KeyValuePair <DateTime, int> > GetTimeStampsFromFrameIndex(byte[] buffer) { List <KeyValuePair <DateTime, int> > times = new List <KeyValuePair <DateTime, int> >(); long utcmask = ((long)DateTimeKind.Utc << 62); long localantimask = ~((long)DateTimeKind.Local << 62); long unspmask = ~((long)3 << 62); try { ASCIIEncoding encoder = new ASCIIEncoding(); string stamp = "--videoboundary--"; byte[] stampbytes = encoder.GetBytes(stamp); int index_of_index = -1; int pos = buffer.Length; while (index_of_index == -1 && pos > 0) { pos -= 5000; index_of_index = ByteArrayUtils.IndexOf(buffer, stampbytes, pos, buffer.Length - pos); } if (index_of_index == -1) { throw new IOException("Invalid buffer"); } pos = index_of_index + stampbytes.Length; while (pos < buffer.Length - 12) { long bytes = BitConverter.ToInt64(buffer, pos); //bytes = bytes | utcmask; //bytes = bytes & localantimask; bytes = bytes & unspmask; DateTime time = DateTime.FromBinary(bytes); //this fixes the timezone issue time = ChangeDateTimeKind(time, DateTimeKind.Utc); int bytepos = BitConverter.ToInt32(buffer, pos + 8); //sometimes there are blank bytes at the end of the file. Don't record these as index entries. //if (bytepos > 0) times.Add(new KeyValuePair <DateTime, int>(time, bytepos)); pos += 12; } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(times); }
public static void StopDiagnosticMode() { try { _recordMemUsageRegularly = false; _diagnosticMemoryThread.Join(); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
public string[] ZipFolder(string folder, string outputFile, int MaxSizeMB) { string[] list = new string[0]; try { StringBuilder sb = new StringBuilder(); sb.AppendFormat("a -tzip \"{0}\" -v{1}m", outputFile, MaxSizeMB); sb.AppendFormat(" \"{0}\"", folder); //_ZipAsyncCallback = callback; DebugMessageLogger.LogEventLevel("Running: {0} {1}", 0, exeLoc, sb.ToString()); ProcessStartInfo info = new ProcessStartInfo(exeLoc, sb.ToString()); info.RedirectStandardOutput = true; info.CreateNoWindow = true; info.UseShellExecute = false; _ZipProcess = Process.Start(info); _reader = _ZipProcess.StandardOutput; ProcessOutputReader(); //find all files in the format outputFile.??? var d = new DirectoryInfo(Path.GetDirectoryName(outputFile)); FileInfo[] infos = d.GetFiles(Path.GetFileName(outputFile) + ".*"); list = new string[infos.Length]; if (infos.Length == 1) { File.Move(infos[0].FullName, outputFile); list[0] = outputFile; } else { for (int i = 0; i < infos.Length; i++) { list[i] = infos[i].FullName; } } DebugMessageLogger.LogEvent("Z7Wrapper - Zip Folder {0} to {1} Files of limit {2}MB", folder, list.Length, MaxSizeMB); return(list); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(list); }
public static string VersionTo2CharCode(Version ver) { try { return(string.Format("{0}{1}", ConvIntToLowerCase(ver.Build), ConvIntToLowerCase(ver.Revision))); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return("-"); }
public static bool GetDimensionsOfImageFromJpegData(byte[] jpegdata, out int width, out int height) { bool success = false; width = 0; height = 0; int loc = 0; try { int trys = 0; while (success == false && loc != -1 && loc < 2000 && trys < 20) { loc = ByteArrayUtils.IndexOf(jpegdata, new byte[] { 0xFF, 0xC0 }, loc, 2000); if (loc > 0) { byte[] heightbyte = new byte[] { jpegdata[loc + 6], jpegdata[loc + 5] }; //make BigEndian byte[] widthbyte = new byte[] { jpegdata[loc + 8], jpegdata[loc + 7] }; height = BitConverter.ToInt16(heightbyte, 0); width = BitConverter.ToInt16(widthbyte, 0); if (height > 0 && height < 65535 && width > 0 && width < 65535) { success = true; } else { success = false; loc += 2; trys++; } } } if (success == false) { DebugMessageLogger.LogEvent("Failed to recover good height ({0}) and width ({1}) from jpeg data. Tried {2} times", width, height, trys); } } catch (Exception ee) { success = false; DebugMessageLogger.LogError(ee); } return(success); }
public void UnZip(string file, string outputfolder) { try { ProcessStartInfo info = new ProcessStartInfo(exeLoc, string.Format("e {0} {1}", file, outputfolder)); // info.RedirectStandardOutput = true; //info.CreateNoWindow = true; // info.UseShellExecute = false; _ZipProcess = Process.Start(info); _ZipProcess.WaitForExit(4000); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
public static void LogProcessOutput(Process proc, string name) { try { LogEvent(String.Format("{0} Started", name)); while (!proc.StandardOutput.EndOfStream) { LogEvent(String.Format("{0} Command Line: {1}", name, proc.StandardOutput.ReadLine())); } LogEvent(String.Format("{0} Ended", name)); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
public static void LogTeamviewerID() { try { var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey( @"SOFTWARE\Wow6432Node\TeamViewer"); foreach (var subkeyname in key.GetSubKeyNames()) { var subkey = key.OpenSubKey(subkeyname); var clientID = subkey.GetValue("ClientID"); DebugMessageLogger.LogEvent("Teamviewer {0} Client ID: {1}", subkeyname, clientID); } } catch (Exception ee) { } }
public static void StartDiagnosticMode() { try { _recordMemUsageRegularly = false; try { if (_diagnosticMemoryThread != null) { _diagnosticMemoryThread.Abort(); } } catch (Exception eeee) { } _recordMemUsageRegularly = true; _diagnosticMemoryThread = new Thread(new ThreadStart(() => { try { while (_recordMemUsageRegularly) { long totmem = GC.GetTotalMemory(true); float privateMB = Process.GetCurrentProcess().PrivateMemorySize64 / 1000000f; DebugMessageLogger.LogEvent("Diagnostic Mode: Private Bytes Usage: {0} MB, GC: {1} MB", privateMB.ToString("n"), (totmem / 1000000f).ToString("n")); Kinesense.Interfaces.Threading.ThreadSleepMonitor.Sleep(10000); } } catch (Exception eee) { DebugMessageLogger.LogError(eee); } })); _diagnosticMemoryThread.Start(); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
protected byte[] Decompress() { byte[] data = null; try { BitmapDecoder decoder; using (MemoryStream memoryStream = new MemoryStream(_CompressedData)) decoder = BitmapDecoder.Create(memoryStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); BitmapFrame bitmapFrame = decoder.Frames[0]; data = new ByteArrayBitmap(bitmapFrame).Data; //bitmapFrame.CopyPixels(data, this.Stride, 0); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(data); }
private void TryToDecodeEncodedDataTo_bitmap() { try { lock (_disposelock) { if (Disposed) { return; } using (MemoryStream memoryStream = new MemoryStream(this.EncodedData)) { System.Drawing.Bitmap bmp = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromStream(memoryStream); _bitmap = ByteArrayBitmap.FromBitmapForce4bpp(bmp); } //this was the way it was done in 2.5 and below //BitmapDecoder decoder; //using (MemoryStream memoryStream = new MemoryStream(this.EncodedData)) // decoder = BitmapDecoder.Create(memoryStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); //BitmapFrame bitmapFrame = decoder.Frames[0]; //_bitmap = new ByteArrayBitmap(bitmapFrame); //string[] mimeTypes = decoder.CodecInfo.MimeTypes.Split(','); //if (mimeTypes.Length > 0) // this.EncodedDataContentType = new ContentType(mimeTypes[0]); // log access for drop on age calc this.EncodedDataContentType = new ContentType("image/jpeg"); _lastDecodedDataAccess = DateTime.Now; TrySetWidthHeight(); } } catch (Exception ee) { System.Diagnostics.Trace.WriteLine(string.Format("No Bitmap and No EncodedData: {0}.{1}", DBTime, DBTime.Millisecond)); DebugMessageLogger.LogError(ee); _bitmap = null; } }
public void Rotate(System.Drawing.RotateFlipType rotate) { try { System.Drawing.Bitmap B = this.Bitmap.ToBitmap(); B.RotateFlip(rotate); using (MemoryStream memoryStream = new MemoryStream()) { B.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Bmp); B.Dispose(); memoryStream.Seek(0, SeekOrigin.Begin); byte[] data = new byte[memoryStream.Length]; memoryStream.Read(data, 0, (int)memoryStream.Length); _bitmap = new ByteArrayBitmap(data); } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }
public static void RunCleanup(TimeSpan olderThan) { Task.Factory.StartNew(() => { try { Thread.CurrentThread.Name = "Run Cleanup"; DateTime now = DateTime.Now; DebugMessageLogger.LogEvent("Looking for log files older than {0} ago", olderThan); List <string> paths = new List <string>(); paths.Add(LogsFolder); foreach (var dir in Directory.GetDirectories(LogsFolder)) { if (!dir.Contains("CommonViewingLogs")) //dont delete viewing logs { paths.Add(dir); } } foreach (var dir in paths) { foreach (var file in Directory.GetFiles(dir, "*.log")) { TimeSpan howold = now - new FileInfo(file).LastWriteTime; if (howold > olderThan) { DebugMessageLogger.LogEvent("Deleting file {0} which is {1} days old", file, howold.Days); File.Delete(file); } } } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } }); }
protected byte[] Compress(byte[] data) { byte[] encodedData = null; try { var encoder = new JpegBitmapEncoderFactory(JpegBitmapEncoderFactory.DefaultJpegQuality).GetBitmapEncoder(); var bitmapSource = BitmapSource.Create(this.Width, this.Height, 96, 96, this.Format, null, data, this.Stride); bitmapSource.Freeze(); encoder.Frames.Add(BitmapFrame.Create(bitmapSource)); using (MemoryStream imageMemoryStream = new MemoryStream()) { encoder.Save(imageMemoryStream); encodedData = imageMemoryStream.ToArray(); } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(encodedData); }
public BitmapSource GetImageFromEncodedData() { BitmapSource bmp = null; try { BitmapDecoder decoder; using (MemoryStream memoryStream = new MemoryStream(this.EncodedData)) decoder = BitmapDecoder.Create(memoryStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); BitmapFrame bitmapFrame = decoder.Frames[0]; bmp = bitmapFrame; //this prevents big memory spikes on playback of HD video. //if(_countGCs++ % 5 == 0) // GC.Collect(); } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(bmp); }
public static void LogClick() { DebugMessageLogger.LogEvent("--USER CLICK--- {0}", new StackFrame(1, true)); }
/// <summary> /// This method looks for the index at the end of the frame packet. This should be in the format DateTime.Int /// following a final "--videoboundary" /// </summary> /// <param name="buffer"></param> /// <param name="stampA"></param> /// <param name="stampB"></param> /// <returns></returns> public static List <KeyValuePair <DateTime, int> > GetTimeStampsFromFrameIndex(byte[] buffer, DateTime start, TimeSpan duration) { List <KeyValuePair <DateTime, int> > times = new List <KeyValuePair <DateTime, int> >(); long utcmask = ((long)DateTimeKind.Utc << 62); long localantimask = ~((long)DateTimeKind.Local << 62); DateTime end = start + duration; //this is because the gob start time from the db can be slightly off the first frame time DateTime startLimit = start.AddSeconds(-120); DateTime endLimit = end.AddSeconds(120); TimeSpan?offset = null; //long unspmask = ~((long)3 << 62); try { ASCIIEncoding encoder = new ASCIIEncoding(); string stamp = "--videoboundary--"; byte[] stampbytes = encoder.GetBytes(stamp); int index_of_index = -1; int pos = buffer.Length; while (index_of_index == -1 && pos > 0) { pos -= 5000; index_of_index = ByteArrayUtils.IndexOf(buffer, stampbytes, pos, buffer.Length - pos); } if (index_of_index == -1) { throw new IOException("Invalid buffer"); } pos = index_of_index + stampbytes.Length; while (pos < buffer.Length - 12) { long bytes = BitConverter.ToInt64(buffer, pos); bytes = bytes | utcmask; bytes = bytes & localantimask; //bytes = bytes & unspmask; DateTime time = DateTime.FromBinary(bytes); //this fixes the timezone issue //time = ChangeDateTimeKind(time, DateTimeKind.Utc); //rationality check, for timezone and daylight savings problems if (time < startLimit || time > endLimit) { if (offset.HasValue == false) { long roundedticks = (long)((time.Ticks / 10000) * 10000); long diff = time.Ticks - roundedticks; if (diff > 5000) ///to unround the number (workaround for a bug on some pcs) { roundedticks += 10000; } DateTime roundedTime = new DateTime(roundedticks); //assume first frame offset = start - roundedTime; DebugMessageLogger.LogEvent("Time is off in this Frame Packet - adjusting by {0}", offset); } time = time + offset.Value; } int bytepos = BitConverter.ToInt32(buffer, pos + 8); //sometimes there are blank bytes at the end of the file. Don't record these as index entries. //if (bytepos > 0) times.Add(new KeyValuePair <DateTime, int>(time, bytepos)); pos += 12; } } catch (Exception ee) { DebugMessageLogger.LogError(ee); } return(times); }
private static void ConvertExceptionToText(Exception e, string extra, int logLevel, string threadSignature) { try { //make sure log is in english Thread.CurrentThread.CurrentCulture = _logCulture; StringBuilder sb = new StringBuilder(); sb.AppendFormat("\r\n\r\n{0} [{1}] [{2}] {3}\r\n", DateTime.Now.ToString(TimeStampFormat), _instanceID, logLevel.ToString(), threadSignature); Exception printException = e; while (printException != null) { sb.AppendFormat("{0}\r\n", printException); sb.AppendFormat("Source: {0}\r\n", printException.Source); sb.AppendFormat("HasInnerException = {0}\r\n", (printException.InnerException != null)); printException = printException.InnerException; } if (!String.IsNullOrEmpty(extra)) { sb.AppendFormat("ExtraInfo: {0}\r\n", extra); } sb.Append("\r\n\r\n"); string message = sb.ToString(); if (message != previousMessage) { if (repeatcount > 1) { WriteToFile(string.Format("\r\nPrevious message written {0} times\r\n", repeatcount)); } previousMessage = message; repeatcount = 0; WriteToFile(message); } else { repeatcount++; } exceptionCount++; if (exceptionCount % 10 == 0) { long totmem = 0; Task t = Task.Factory.StartNew( () => { Thread.CurrentThread.Name = "Log Memory Use"; try { totmem = GC.GetTotalMemory(true); float privateMB = Process.GetCurrentProcess().PrivateMemorySize64 / 1000000f; DebugMessageLogger.LogEvent("Exception count: {0} Private Bytes Usage: {1} MB, GC: {2} MB", exceptionCount, privateMB.ToString("n"), (totmem / 1000000f).ToString("n")); } catch (Exception eeex) { } } ); //t.Wait(200); //Calculate Memoryusage //if (exceptionCount % 50 == 0) //{ // if ((DateTime.Now - _LastHDDCheckTime).TotalSeconds > 300) // { // _LastHDDCheckTime = DateTime.Now; // // check DB HDD // Task.Factory.StartNew(() => // { // try // { // long res = Useful.CheckHDDSize.HowMuchDBSpaceLeft(); // if (res != -1 && (res / (1 << 30)) < 1) // { // LogEventLevel("################## WARNING < 1 GB DB Space Available ####################", 0); // } // if (CheckHDDSize.DBDrive != null) // LogEventLevel("Database Drive " + CheckHDDSize.DBDrive.RootDirectory + " has " + (res / (1024 * 1024)).ToString() + "Mb space left", 0); // } // catch (Exception er) // { // Kinesense.Interfaces.DebugMessageLogger.LogError(er); // } // }); // // Check temp HDD // Task.Factory.StartNew(() => // { // try // { // long res = Useful.CheckHDDSize.HowMuchTEMPSpaceLeft(); // if (res != -1 && (res / (1 << 30)) < 1) // { // LogEventLevel("################## WARNING < 1 GB DB Space Available ####################", 0); // } // if (CheckHDDSize.TEMPDrive != null) // LogEventLevel("Temp Drive " + CheckHDDSize.TEMPDrive.RootDirectory + " has " + (res / (1024 * 1024)).ToString() + "Mb space left", 0); // } // catch (Exception er) // { // Kinesense.Interfaces.DebugMessageLogger.LogError(er); // } // }); // } //} } else if (e is System.OutOfMemoryException || (e.InnerException != null && e.InnerException is System.OutOfMemoryException)) { if ((DateTime.Now - _MostRecentMemoryTest).TotalSeconds > 60) { long totmem = 0; Task t = Task.Factory.StartNew(() => { totmem = GC.GetTotalMemory(true); float privateMB = Process.GetCurrentProcess().PrivateMemorySize64 / 1000000f; DebugMessageLogger.LogEvent("OutOfMemoryException Private Bytes Usage: {0} MB, GC: {1} MB", privateMB.ToString("n"), (totmem / 1000000f).ToString("n")); }); t.Wait(200); _MostRecentMemoryTest = DateTime.Now; } //Calculate Memoryusage } } catch (Exception ee) { //System.Windows.MessageBox.Show(ee.Message); } finally { Thread.CurrentThread.CurrentCulture = _currentculture; } }