/// <summary> /// 新建词条 /// </summary> public bool AddKeyword(string keyword, string channelName) { if (string.IsNullOrEmpty(channelName)) { return(this.FaildMessage("频道为空")); } string keyId = keyword.GetKey(); Regex regex = new Regex(@"^~(?<Content>.+)~$"); if (regex.IsMatch(keyword)) { keyword = regex.Match(keyword).Groups["Content"].Value; } using (DbExecutor db = NewExecutor()) { db.ExecuteNonQuery(CommandType.StoredProcedure, "tran_AddKeyword", new { KeyID = keyId, Content = keyword, Channel = channelName }); MemoryUtils.Remove(channelName); } return(true); }
private static void CopyStreamToPointer(Transaction tx, Stream value, byte *pos) { TemporaryPage tmp; using (tx.Environment.GetTemporaryPage(tx, out tmp)) { var tempPageBuffer = tmp.TempPageBuffer; var tempPagePointer = tmp.TempPagePointer; while (true) { var read = value.Read(tempPageBuffer, 0, AbstractPager.PageSize); if (read == 0) { break; } MemoryUtils.CopyInline(pos, tempPagePointer, read); pos += read; if (read != tempPageBuffer.Length) { break; } } } }
public void Save(Stream stream) { MemoryUtils.WriteStruct(stream, Header); MemoryUtils.WriteAnsiString(MaterialName, stream); bool tangents = (Header.Flags & AMeshFlags.HaveTangents) != AMeshFlags.None; if (tangents) { for (ushort i = 0; i < Header.VerticesCount; ++i) { MemoryUtils.WriteStruct(stream, Position[i]); MemoryUtils.WriteStruct(stream, UV0[i]); MemoryUtils.WriteStruct(stream, Normal[i]); MemoryUtils.WriteStruct(stream, Tangent[i]); } } else { for (ushort i = 0; i < Header.VerticesCount; ++i) { MemoryUtils.WriteStruct(stream, Position[i]); MemoryUtils.WriteStruct(stream, Normal[i]); MemoryUtils.WriteStruct(stream, UV0[i]); } } BinaryWriter writer = new BinaryWriter(stream); foreach (var index in Indices) { writer.Write(index); } }
private Dictionary <string, ProjectAnalysisResult> AnalyzeProjects( string solutionFileName, List <string> projects, List <AnalyzerResult> analyzerResult, List <ProjectResult> analysisActions, bool isIncremental = false, string targetFramework = DEFAULT_TARGET) { _logger.LogInformation("Memory Consumption before AnalyzeProjects: "); MemoryUtils.LogMemoryConsumption(_logger); var results = projects .Select((project) => new KeyValuePair <string, ProjectAnalysisResult>( project, AnalyzeProject( project, solutionFileName, analyzerResult, analysisActions, isIncremental, targetFramework))) .Where(p => p.Value != null) .ToDictionary(p => p.Key, p => p.Value); _logger.LogInformation("Memory Consumption after AnalyzeProjects: "); MemoryUtils.LogMemoryConsumption(_logger); return(results); }
public static void Connect(Peer Peer, string Host, int Port, int Ms, bool isSecure, bool isLocal, EventHandler <SocketAsyncEventArgs> Completed) { IPAddress IP = MemoryUtils.Host2IP(Host); if (IP == null) { MemoryUtils.Error("Could not resolve host " + Host); return; } SocketAsyncEventArgs e = new SocketAsyncEventArgs(); e.RemoteEndPoint = new IPEndPoint(IP, Port); e.Completed += Completed; Socket Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket.NoDelay = true; Socket.Blocking = false; Socket.ExclusiveAddressUse = true; Socket.LingerState = new LingerOption(true, 0); e.UserToken = Create(Socket, Peer, isSecure, isLocal); if (!Socket.ConnectAsync(e)) { Completed(null, e); } }
protected override void _OUTTransaction(USBTransfer transfer, USBTransaction uTransaction, bool toggle, void *buffer, ushort length) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: OUT Transaction"); BasicConsole.DelayOutput(5); #endif UHCITransaction uT = new UHCITransaction(); uTransaction.underlyingTz = uT; uT.inBuffer = null; uT.inLength = 0; uT.qTD = CreateQTD_IO((UHCI_QueueHead_Struct *)transfer.underlyingTransferData, (uint *)1, UHCI_Consts.TD_OUT, toggle, length, transfer.device.address, transfer.endpoint, transfer.packetSize); uT.qTDBuffer = uT.qTD->virtBuffer; if (buffer != null && length != 0) { MemoryUtils.MemCpy_32((byte *)uT.qTDBuffer, (byte *)buffer, length); } if (transfer.transactions.Count > 0) { UHCITransaction uLastTransaction = (UHCITransaction)((USBTransaction)(transfer.transactions[transfer.transactions.Count - 1])).underlyingTz; uLastTransaction.qTD->next = (((uint)VirtMemManager.GetPhysicalAddress(uT.qTD) & 0xFFFFFFF0) | UHCI_Consts.BIT_Vf); // build TD queue uLastTransaction.qTD->q_next = uT.qTD; } }
public void LoadLevelData() { LevelData = new List <LevelData>(); // dump all single player save slots var rawLevelData = MemoryUtils.DumpSaveSlots(Gecko, 0, SaveSlotsAddress, 768); // read data from slots var j = 0; while (j < rawLevelData.Length) { var levelNumber = rawLevelData[j]; // check if an empty save slot if (levelNumber == uint.MaxValue) { break; } var clearState = rawLevelData[j + 1]; var scroll = Convert.ToBoolean(rawLevelData[j + 2]); // add to the list LevelData.Add(new LevelData(levelNumber, clearState, scroll)); // move to next slot j += 3; } }
public async Task <Dictionary <string, ProjectAnalysisResult> > AnalyzeSolutionIncremental( string solutionFilename, List <string> projects, string targetFramework = DEFAULT_TARGET) { try { var analyzerResults = await RunCoderlyzerAnalysis(solutionFilename); var analysisActions = AnalyzeActions(projects, targetFramework, analyzerResults, solutionFilename); var solutionAnalysisResult = AnalyzeProjects( solutionFilename, projects, analyzerResults, analysisActions, isIncremental: true, targetFramework); var projectActions = projects .Select((project) => new KeyValuePair <string, ProjectActions> (project, analysisActions.FirstOrDefault(p => p.ProjectFile == project)?.ProjectActions ?? new ProjectActions())) .Where(p => p.Value != null) .ToDictionary(p => p.Key, p => p.Value); return(solutionAnalysisResult); } catch (OutOfMemoryException e) { _logger.LogError("Analyze solution {0} with error {1}", solutionFilename, e); MemoryUtils.LogMemoryConsumption(_logger); throw e; } finally { CommonUtils.RunGarbageCollection(_logger, "PortingAssistantAnalysisHandler.AnalyzeSolutionIncremental"); } }
static TranslateUtils() { APIURL = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build()["studio:language"]; if (string.IsNullOrEmpty(APIURL)) { return; } Console.WriteLine("触发翻译器静态构造"); Timer timer = new Timer(60 * 1000) { Enabled = true }; timer.Elapsed += (sender, e) => { if (UPDATETIME != GetDataTime()) { Console.WriteLine("语言包存在更新"); MemoryUtils.Set(KEY, GetAPIData(), TimeSpan.FromDays(7)); } }; timer.Start(); }
public static object ReadHeader(Stream data) { var baseHeader = data.ReadStruct <BaseHeader>(); var baseSize = Marshal.SizeOf <BaseHeader>(); if (baseHeader.size < baseSize) { throw new Exception("Unexpected header size"); } if (baseHeader.size == baseSize) { return(baseHeader); } if (baseHeader.platformId.Value == 0x44583131) { //dx11 platform var dx11Size = Marshal.SizeOf <DX11Header>(); var extraBytesCount = dx11Size - baseSize; var extraBytes = data.ReadBytes(extraBytesCount); var baseBytes = MemoryUtils.StructToBytes(baseHeader); List <byte> dx11Bytes = new List <byte>(); dx11Bytes.AddRange(baseBytes); dx11Bytes.AddRange(extraBytes); return(MemoryUtils.BytesToStruct <DX11Header>(dx11Bytes.ToArray())); } throw new Exception("Unknown platform"); }
public Dictionary <PackageVersionPair, Task <PackageDetails> > GetNugetPackages(List <PackageVersionPair> packageVersions, string pathToSolution, bool isIncremental = false, bool incrementalRefresh = false) { _logger.LogInformation("Memory usage before GetNugetPackages: "); MemoryUtils.LogMemoryConsumption(_logger); var packageVersionsToQuery = new List <PackageVersionPair>(); var tasks = packageVersions.Select(packageVersion => { var isNewCompatibilityTask = _compatibilityTaskCompletionSources.TryAdd(packageVersion, new TaskCompletionSource <PackageDetails>()); if (isNewCompatibilityTask) { packageVersionsToQuery.Add(packageVersion); } var packageVersionPairResult = _compatibilityTaskCompletionSources[packageVersion]; return(new Tuple <PackageVersionPair, Task <PackageDetails> >(packageVersion, packageVersionPairResult.Task)); }).ToDictionary(t => t.Item1, t => t.Item2); _logger.LogInformation("Checking compatibility for {0} packages", packageVersionsToQuery.Count); Process(packageVersionsToQuery, pathToSolution, isIncremental, incrementalRefresh); _logger.LogInformation("Memory usage after GetNugetPackages: "); MemoryUtils.LogMemoryConsumption(_logger); return(tasks); }
public async Task <string> RequestOAuth2Token(string appId) { GCHandle handle; bool resultSuccess = false; string data = null; var semaphore = new SemaphoreSlim(0, 1); unsafe { void ResolveTask(bool success, string token) { resultSuccess = success; data = token; semaphore.Release(); } DiscordOAuth2TokenResultModuleDelegate resolveTask = ResolveTask; handle = GCHandle.Alloc(resolveTask); var appIdPtr = MemoryUtils.StringToHGlobalUtf8(appId); core.Library.Client.Core_Discord_GetOAuth2Token(core.NativePointer, appIdPtr, resolveTask); Marshal.FreeHGlobal(appIdPtr); } await semaphore.WaitAsync(); handle.Free(); semaphore.Dispose(); if (!resultSuccess) { throw new Exception("Failed to request OAuth2 token"); } return(data); }
private int CompareData(ValueReader other, int len) { if (_buffer != null) { fixed(byte *a = _buffer) { if (other._buffer != null) { fixed(byte *b = other._buffer) { return(MemoryUtils.Compare(a, b, len)); } } return(MemoryUtils.Compare(a, other._val, len)); } } if (other._buffer != null) { fixed(byte *b = other._buffer) { return(MemoryUtils.Compare(_val, b, len)); } } return(MemoryUtils.Compare(_val, other._val, len)); }
public void WriteGather(long position, IntPtr[] pages) { _locker.EnterWriteLock(); try { if (position != _lastPos) { throw new InvalidOperationException("Journal writes must be to the next location in the journal"); } var size = pages.Length * AbstractPager.PageSize; _lastPos += size; var handle = Marshal.AllocHGlobal(size); var buffer = new Buffer { Handle = handle, Pointer = (byte *)handle.ToPointer(), SizeInPages = pages.Length }; _buffers = _buffers.Append(buffer); for (int index = 0; index < pages.Length; index++) { MemoryUtils.Copy(buffer.Pointer + (index * AbstractPager.PageSize), (byte *)pages[index].ToPointer(), AbstractPager.PageSize); } } finally { _locker.ExitWriteLock(); } }
public void DeepCopyShouldCreateExactAndIndependentCopyOfAnObject() { var instance = new CustomSerializableType { DateTimeValueType = DateTime.Now.AddDays(1).AddMilliseconds(123).AddTicks(123), NumericValueType = 777, StringValueType = Guid.NewGuid().ToString(), ReferenceType = new CustomSerializableType { DateTimeValueType = DateTime.Now, StringValueType = Guid.NewGuid().ToString() } }; var deepCopy = MemoryUtils.DeepCopy(instance, true); Assert.IsNotNull(deepCopy); Assert.IsFalse(ReferenceEquals(instance, deepCopy)); Assert.That(instance.NumericValueType == deepCopy.NumericValueType); Assert.That(instance.DateTimeValueType == deepCopy.DateTimeValueType); Assert.That(instance.StringValueType == deepCopy.StringValueType); Assert.IsFalse(ReferenceEquals(instance.ReferenceType, deepCopy.ReferenceType)); Assert.That(instance.ReferenceType.DateTimeValueType == deepCopy.ReferenceType.DateTimeValueType); Assert.That(instance.ReferenceType.StringValueType == deepCopy.ReferenceType.StringValueType); }
public void ReloadWeapons() { _weapons.Clear(); EquippedWeapon = Gecko.peek((uint)GearAddress.EquippedWeapon + Offset); var weaponData = MemoryUtils.DumpSaveSlots(Gecko, Offset, (uint)GearAddress.Weapons, 5120); // read data from slots var j = 0; while (j < weaponData.Length) { var id = weaponData[j]; // check if an empty save slot if (id.Equals(uint.MaxValue)) { break; } var number = weaponData[j + 1]; var sub = (SubWeapon)weaponData[j + 2]; var special = (SpecialWeapon)weaponData[j + 3]; var turfInked = weaponData[j + 4]; var timestamp = weaponData[j + 7]; var newFlag = weaponData[j + 8] == 0x0; AddWeapon(new Weapon(id, number, sub, special, turfInked, timestamp, newFlag)); // move to next slot j += 10; } }
public async Task <HttpResponse> Get(string url) { CheckIfEntityExists(); GCHandle handle; HttpResponse?data = null; var semaphore = new SemaphoreSlim(0, 1); unsafe { void ResolveTask(int statusCode, string body, IntPtr headerKeys, IntPtr headerValues, int headerSize) { data = GetHttpResponse(statusCode, body, headerKeys, headerValues, headerSize); semaphore.Release(); } HttpResponseModuleDelegate resolveTask = ResolveTask; handle = GCHandle.Alloc(resolveTask); var urlPtr = MemoryUtils.StringToHGlobalUtf8(url); Core.Library.Client.HttpClient_Get(NativePointer, urlPtr, resolveTask); Marshal.FreeHGlobal(urlPtr); } await semaphore.WaitAsync(); handle.Free(); semaphore.Dispose(); return(data.Value); }
internal int CompareDataInline(Slice other, ushort size) { if (Array != null) { fixed(byte *a = Array) { if (other.Array != null) { fixed(byte *b = other.Array) { return(MemoryUtils.CompareInline(a, b, size)); } } else { return(MemoryUtils.CompareInline(a, other.Pointer, size)); } } } if (other.Array != null) { fixed(byte *b = other.Array) { return(MemoryUtils.CompareInline(Pointer, b, size)); } } else { return(MemoryUtils.CompareInline(Pointer, other.Pointer, size)); } }
private void OnWriteExternalFlashStarted(byte[] flashMemoryImage, MemoryLayout flashMemoryLayout, Operation.CompletedOperationDelegate onOperationComplete, bool diffWrite, bool verify) { var KWP2000CommViewModel = App.CommInterfaceViewModel as KWP2000Interface_ViewModel; var settings = new WriteExternalFlashOperation.WriteExternalFlashSettings(); settings.CheckIfWriteRequired = diffWrite; settings.OnlyWriteNonMatchingSectors = diffWrite; settings.VerifyWrittenData = verify; settings.EraseEntireFlashAtOnce = false; settings.SecuritySettings.RequestSeed = KWP2000CommViewModel.SeedRequest; settings.SecuritySettings.SupportSpecialKey = KWP2000CommViewModel.ShouldSupportSpecialKey; settings.SecuritySettings.UseExtendedSeedRequest = KWP2000CommViewModel.ShouldUseExtendedSeedRequest; var sectorImages = MemoryUtils.SplitMemoryImageIntoSectors(flashMemoryImage, flashMemoryLayout); App.CurrentOperation = new WriteExternalFlashOperation(KWP2000CommViewModel.KWP2000CommInterface, KWP2000CommViewModel.DesiredBaudRates, settings, sectorImages); App.CurrentOperation.CompletedOperationEvent += onOperationComplete; App.OperationInProgress = true; App.PercentOperationComplete = 0.0f; App.DisplayStatusMessage("Writing ECU flash memory.", StatusMessageType.USER); App.CurrentOperation.Start(); }
/// <summary> /// 显示验证码 /// </summary> /// <param name="key"></param> /// <param name="width"></param> /// <param name="height"></param> /// <returns></returns> private Result ShowCode(string key, int width, int height) { string random = WebAgent.GetRandom(0, 9999).ToString().PadLeft(4, '0'); MemoryUtils.Set(key, random, TimeSpan.FromMinutes(5)); using (Bitmap bitmap = new Bitmap(width, height)) { Bitmap bg = (Bitmap) new ResourceManager(typeof(Resources)).GetObject("validcode_bg"); Rectangle rectangle = new Rectangle(WebAgent.GetRandom(0, bg.Width - width), WebAgent.GetRandom(0, bg.Height - height), width, height); using (Graphics g = Graphics.FromImage(bitmap)) { g.Clear(Color.White); g.DrawImage(bg, new Rectangle(0, 0, width, height), rectangle, GraphicsUnit.Pixel); for (int i = 0; i < random.Length; i++) { Bitmap code = (Bitmap) new ResourceManager(typeof(Resources)).GetObject($"validcode_{random[i]}"); Rectangle codeRectangle = new Rectangle(width / random.Length * i + WebAgent.GetRandom(-5, 5), WebAgent.GetRandom(-5, 5), width / 4, height); g.DrawImage(code, codeRectangle, new Rectangle(0, 0, code.Width, code.Height), GraphicsUnit.Pixel); } } using (MemoryStream ms = new MemoryStream()) { bitmap.Save(ms, ImageFormat.Png); return(new Result(ContentType.PNG, ms.ToArray())); } } }
private void OnReadExternalFlashStarted(bool checkIfReadRequired, bool onlyReadRequiredSectors, bool shouldVerifyReadData, byte[] baseImage, MemoryLayout flashLayout, Operation.CompletedOperationDelegate operationCompletedDel) { var readImage = baseImage; if ((readImage == null) || (readImage.Length != flashLayout.Size)) { readImage = new byte[flashLayout.Size]; //fill the memory image with 0xFF because that is what blank data in the flash chip is for (int x = 0; x < readImage.Length; x++) { readImage[x] = 0xFF; } } var sectorImages = MemoryUtils.SplitMemoryImageIntoSectors(readImage, flashLayout); var KWP2000CommViewModel = App.CommInterfaceViewModel as KWP2000Interface_ViewModel; var settings = new ReadExternalFlashOperation.ReadExternalFlashSettings(); settings.CheckIfSectorReadRequired = checkIfReadRequired; settings.OnlyReadNonMatchingSectors = onlyReadRequiredSectors; settings.VerifyReadData = shouldVerifyReadData; settings.SecuritySettings.RequestSeed = KWP2000CommViewModel.SeedRequest; settings.SecuritySettings.SupportSpecialKey = KWP2000CommViewModel.ShouldSupportSpecialKey; settings.SecuritySettings.UseExtendedSeedRequest = KWP2000CommViewModel.ShouldUseExtendedSeedRequest; App.CurrentOperation = new ReadExternalFlashOperation(KWP2000CommViewModel.KWP2000CommInterface, KWP2000CommViewModel.DesiredBaudRates, settings, sectorImages); App.CurrentOperation.CompletedOperationEvent += operationCompletedDel; App.DisplayStatusMessage("Reading ECU flash memory.", StatusMessageType.USER); App.CurrentOperation.Start(); }
public async Task <Dictionary <string, ProjectAnalysisResult> > AnalyzeSolution( string solutionFilename, List <string> projects, string targetFramework = DEFAULT_TARGET) { try { var analyzerResults = await RunCoderlyzerAnalysis(solutionFilename); var analysisActions = AnalyzeActions(projects, targetFramework, analyzerResults, solutionFilename); var solutionAnalysisResult = AnalyzeProjects( solutionFilename, projects, analyzerResults, analysisActions, isIncremental: false, targetFramework); return(solutionAnalysisResult); } catch (OutOfMemoryException e) { _logger.LogError("Analyze solution {0} with error {1}", solutionFilename, e); MemoryUtils.LogMemoryConsumption(_logger); throw e; } finally { CommonUtils.RunGarbageCollection(_logger, "PortingAssistantAnalysisHandler.AnalyzeSolution"); } }
/// <summary> /// 清除缓存(本地缓存+Redis) /// </summary> /// <param name="adminId"></param> public void RemoveCache(int adminId) { string key = $"SYSTEMADMIN:{adminId}"; MemoryUtils.Remove(key); AdminCaching.Instance().RemoveCache(adminId); }
protected override void NewConnection(object sender, SocketArgs args) { try { string request = string.Format( "GET {0} HTTP/1.1" + Environment.NewLine + "Upgrade: WebSocket" + Environment.NewLine + "Connection: Upgrade" + Environment.NewLine + "Host: {1}" + Environment.NewLine + "Origin: {2}" + Environment.NewLine + "Pragma: no-cache" + Environment.NewLine + "Cache-Control: no-cache" + Environment.NewLine + "Accept-Encoding: gzip, deflate" + Environment.NewLine + "Sec-WebSocket-Version: 13" + Environment.NewLine + "Sec-WebSocket-Key: " + Hybi.GenerateKey() + "" + Environment.NewLine + "Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover; server_no_context_takeover" + Environment.NewLine + Environment.NewLine, "/", args.Socket.Endpoint, "null"); if (!this.SendRaw(MemoryUtils.ToLatin(request))) { Console.WriteLine("Sendraw failed?"); throw new Exception("Sendraw failed?"); } } catch (ObjectDisposedException ex) { Console.WriteLine(ex.Message); return; } }
internal Page ModifyPage(long num, Tree tree, Page page) { _env.AssertFlushingNotFailed(); page = page ?? GetReadOnlyPage(num); if (page.Dirty) { return(page); } if (_dirtyPages.Contains(num)) { page.Dirty = true; return(page); } var newPage = AllocatePage(1, PageFlags.None, num); // allocate new page in a log file but with the same number MemoryUtils.Copy(newPage.Base, page.Base, AbstractPager.PageSize); newPage.LastSearchPosition = page.LastSearchPosition; newPage.LastMatch = page.LastMatch; tree.RecentlyFoundPages.Reset(num); return(newPage); }
public static unsafe Version getBTD6Version(string btd6Dir) { // GlobalGameManagers contains version string. // Can move by a few bytes in updates, instead scan for it. Version v; byte[] file = File.ReadAllBytes(btd6Dir + "\\BloonsTD6_Data\\globalgamemanagers"); Int64 VersionStructOffset = 0; fixed(byte *pFile = file) { // The signature is only a few bytes away, the next period should always be the peroid in the version (12.2) VersionStructOffset = MemoryUtils.AOBScan(pFile, file.Length, BTD6VerisonInfoSignature); if (VersionStructOffset == 0) { throw new Exception("Error, failed to find BTD6's version"); } // Now we scan for the peroid (12.2) the . for (Int64 i = VersionStructOffset + BTD6VerisonInfoSignature.Length; i < file.Length; i++) { if (pFile[i] == 0x2E) { byte[] versionBytes = MemoryUtils.BytesBetweenNull(pFile, file.Length, i); int periodPos = 0; for (int k = 0; k < versionBytes.Length; k++) { if (versionBytes[k] == 0x2e) { periodPos = k; break; } } byte[] majorVersionBytes = new byte[periodPos]; byte[] minorVersionBytes = new byte[versionBytes.Length - (periodPos + 1)]; Buffer.BlockCopy(versionBytes, 0, majorVersionBytes, 0, periodPos); Buffer.BlockCopy(versionBytes, periodPos + 1, minorVersionBytes, 0, versionBytes.Length - (periodPos + 1)); string majorVersionString = Encoding.UTF8.GetString(majorVersionBytes); string minorVersionString = Encoding.UTF8.GetString(minorVersionBytes); v = new Version(int.Parse(majorVersionString), int.Parse(minorVersionString)); return(v); } } } throw new Exception("Error, unable to get BTD6 Version"); }
public static void Init(EventManagerConfiguration config) { Debug.Assert(config.MaxEvents > 0u); Logger.Trace <EventManager>($"Initialize {nameof(EventManager)} with max events {config.MaxEvents}"); _maxEvents = (int)config.MaxEvents; _events = MemoryUtils.AllocateBlock <Event>(config.MaxEvents * 2); }
public void DeepCopyDoesNotThrowWhenCopyNonSerializableInstanceAndErrorsDisabled() { var nonSerializableInstance = new CustomNonSerializableType(); object result = null; Assert.DoesNotThrow(() => result = MemoryUtils.DeepCopy(nonSerializableInstance, false)); Assert.IsNull(result); }
public void GetMetaData(string key, out MValueConst value) { unsafe { var stringPtr = MemoryUtils.StringToHGlobalUtf8(key); value = new MValueConst(Core, Core.Library.Shared.BaseObject_GetMetaData(BaseObjectNativePointer, stringPtr)); Marshal.FreeHGlobal(stringPtr); } }
public static void CopyTo(Transaction tx, NodeHeader *node, byte *dest) { if (node->Flags == (NodeFlags.PageRef)) { var overFlowPage = tx.GetReadOnlyPage(node->PageNumber); MemoryUtils.Copy(dest, overFlowPage.Base + Constants.PageHeaderSize, overFlowPage.OverflowSize); } MemoryUtils.Copy(dest, (byte *)node + node->KeySize + Constants.NodeHeaderSize, node->DataSize); }