public static HashEntry[] ToHashEntryArray(this Dictionary<string, string> Items) { var Entries = new HashEntry[Items.Count]; int i = 0; foreach (var Item in Items) { Entries[i++] = new HashEntry(Item.Key, Item.Value); } return Entries; }
public LngFile(Stream fileStream) { using (LngBinaryReader b = new LngBinaryReader(EndianBitConverter.Big, fileStream)) { byte[] keys, values; hasChanges = false; magic = b.ReadInt32(); // SIZE - Skip b.ReadInt32(); // Hash Section (HSHS) hshs = new Hshs(b); // Hash Table (HSHT) hsht = new Hsht(b); // Offsets (SIDA) sida = new SidA(b); // Keys (SIDB) sidb = new SidB(b); keys = b.ReadBytes(sidb.Size); // Values (LNGB) lngb = new LngB(b); values = b.ReadBytes(lngb.Size); count = sida.Entry.Length; for (int i = 0; i < sida.Entry.Length; i++) { HashEntry hEntry = new HashEntry(); hEntry.Key = ReadTerminatedString(keys, sida.Entry[i].KeyOffset, 0x00); hEntry.Value = ReadTerminatedString(values, sida.Entry[i].ValueOffset, 0x00); hsht.Table[GetHash(hEntry.Key)].Add(hEntry); } } }
public static HashEntry[] ToHashEntryArray(this IEnumerable<KeyValuePair<string, string>> Items) { var Entries = new HashEntry[Items.Count()]; int i = 0; foreach (var Item in Items) { Entries[i++] = new HashEntry(Item.Key, Item.Value); } return Entries; }
public EmbeddingScan(HashEntry[] hashEntries) { this.m_AliquotOrderId = hashEntries[0].Value; this.m_ProcessorStartTime = Business.Helper.DateTimeExtensions.NullableDateTimeFromString(hashEntries[1].Value); this.m_ProcessorFixationDuration = Business.Helper.DateTimeExtensions.NullableTimeSpanFromString(hashEntries[2].Value); this.m_DateScanned = DateTime.Parse(hashEntries[3].Value); this.m_ScannedById = Convert.ToInt32(hashEntries[4].Value); this.m_ScannedBy = hashEntries[5].Value; this.m_Updated = Convert.ToBoolean(hashEntries[6].Value); }
public static HashEntry[] ToHashEntries(this IEnumerable<KeyValuePair<string, string>> keyValuePairs) { var hashEntry = new HashEntry[keyValuePairs.Count()]; int i = 0; foreach (var kvp in keyValuePairs) { hashEntry[i] = new HashEntry(kvp.Key, kvp.Value); i++; } return hashEntry; }
/// <summary> /// Initializes a new instance of the /// Sentinel.OAuth.TokenManagers.RedisTokenRepository.Models.RedisRefreshToken class. /// </summary> /// <param name="hashEntries">The hash entries.</param> public RedisRefreshToken(HashEntry[] hashEntries) { var clientId = hashEntries.FirstOrDefault(x => x.Name == "ClientId"); var redirectUri = hashEntries.FirstOrDefault(x => x.Name == "RedirectUri"); var subject = hashEntries.FirstOrDefault(x => x.Name == "Subject"); var token = hashEntries.FirstOrDefault(x => x.Name == "Token"); var validTo = hashEntries.FirstOrDefault(x => x.Name == "ValidTo"); var created = hashEntries.FirstOrDefault(x => x.Name == "Created"); this.ClientId = clientId.Value.HasValue ? clientId.Value.ToString() : string.Empty; this.RedirectUri = redirectUri.Value.HasValue ? redirectUri.Value.ToString() : string.Empty; this.Subject = subject.Value.HasValue ? subject.Value.ToString() : string.Empty; this.Token = token.Value.HasValue ? token.Value.ToString() : string.Empty; this.ValidTo = validTo.Value.HasValue ? JsonConvert.DeserializeObject<DateTime>(validTo.Value.ToString()) : DateTime.MinValue; this.Created = created.Value.HasValue ? JsonConvert.DeserializeObject<DateTime>(created.Value.ToString()) : DateTime.MinValue; }
/// <summary> /// Initializes a new instance of the /// Sentinel.OAuth.TokenManagers.RedisTokenRepository.Models.RedisAuthorizationCode class. /// </summary> /// <param name="hashEntries">The hash entries.</param> public RedisAuthorizationCode(HashEntry[] hashEntries) { var clientId = hashEntries.FirstOrDefault(x => x.Name == "ClientId"); var redirectUri = hashEntries.FirstOrDefault(x => x.Name == "RedirectUri"); var subject = hashEntries.FirstOrDefault(x => x.Name == "Subject"); var code = hashEntries.FirstOrDefault(x => x.Name == "Code"); var ticket = hashEntries.FirstOrDefault(x => x.Name == "Ticket"); var validTo = hashEntries.FirstOrDefault(x => x.Name == "ValidTo"); var created = hashEntries.FirstOrDefault(x => x.Name == "Created"); this.ClientId = clientId.Value.HasValue ? clientId.Value.ToString() : string.Empty; this.RedirectUri = redirectUri.Value.HasValue ? redirectUri.Value.ToString() : string.Empty; this.Subject = subject.Value.HasValue ? subject.Value.ToString() : string.Empty; this.Code = code.Value.HasValue ? code.Value.ToString() : string.Empty; this.Ticket = ticket.Value.HasValue ? ticket.Value.ToString() : string.Empty; this.ValidTo = validTo.Value.HasValue ? JsonConvert.DeserializeObject<DateTime>(validTo.Value.ToString()) : DateTime.MinValue; this.Created = created.Value.HasValue ? JsonConvert.DeserializeObject<DateTime>(created.Value.ToString()) : DateTime.MinValue; }
public void Load(X360IO io) { IO = io; IO.Stream.Position = 0x0; Magic = IO.Reader.ReadInt64(); if (Magic != 0x5343455546000000) return; Version = IO.Reader.ReadInt64(); ImageVersion = IO.Reader.ReadInt64(); FileCount = IO.Reader.ReadInt64(); HeaderSize = IO.Reader.ReadInt64(); DataSize = IO.Reader.ReadInt64(); Files = new List<FileEntry>(); for(int i = 0; i < FileCount; i++) { FileEntry entry = new FileEntry { ID = IO.Reader.ReadInt64(), Offset = IO.Reader.ReadInt64(), Size = IO.Reader.ReadInt64(), Padding = IO.Reader.ReadInt64() }; Files.Add(entry); } Hashes = new List<HashEntry>(); for(int i = 0; i < FileCount; i++) { HashEntry entry = new HashEntry(); entry.FileID = IO.Reader.ReadInt64(); entry.HMACSHA1 = IO.Reader.ReadBytes(0x14); entry.Padding = IO.Reader.ReadInt32(); Hashes.Add(entry); Files[(int) entry.FileID].Hash = entry; } HeaderHash = IO.Reader.ReadBytes(0x14); Padding = IO.Reader.ReadBytes(0xC); }
public TranspositionTable(Field field) { Field_ = field; HashEntries_ = new HashEntry[AiSettings.HashTableSize]; }
public void HashSet_1() { HashEntry[] hashFields = new HashEntry[0]; wrapper.HashSet("key", hashFields, CommandFlags.None); mock.Verify(_ => _.HashSet("prefix:key", hashFields, CommandFlags.None)); }
public DBCache(Type type, IDatabase database) : base(type, database) { this.targetObj = Activator.CreateInstance(type); this.nullEntry = new HashEntry(); }
public static HashEntry[] GetEntrys <T>(T t) { Type type = t.GetType(); PropertyInfo[] pInfos = type.GetProperties(); var entryArr = new HashEntry[pInfos.Length]; for (int i = 0; i < pInfos.Length; i++) { var val = pInfos[i].GetValue(t); //枚举 if (pInfos[i].PropertyType.IsEnum) { entryArr[i] = new HashEntry(pInfos[i].Name, (int)val); } //int else if (pInfos[i].PropertyType.FullName == typeof(int).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (int)val : 0); } //int||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <int>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? ((int?)val) : 0); } //byte else if (pInfos[i].PropertyType.FullName == typeof(byte).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (byte)val : 0); } //byte||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <byte>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? ((byte?)val) : 0); } //string else if (pInfos[i].PropertyType.FullName == typeof(string).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (string)val : string.Empty); } //date else if (pInfos[i].PropertyType.FullName == typeof(DateTime).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? val.ToString() : string.Empty); } //date||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <DateTime>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? ((Nullable <DateTime>)val).ToString() : string.Empty); } //bool else if (pInfos[i].PropertyType.FullName == typeof(bool).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (bool)val : false); } //bool||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <bool>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (bool?)val : false); } //long else if (pInfos[i].PropertyType.FullName == typeof(long).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToInt32(val) : 0); } //long||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <long>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? (long?)val : 0); } //decimal else if (pInfos[i].PropertyType.FullName == typeof(decimal).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToDouble(val) : 0); } //decimal||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <decimal>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToDouble((decimal?)val) : 0); } //guid else if (pInfos[i].PropertyType.FullName == typeof(Guid).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? ((Guid)val).ToString() : string.Empty); } //guid||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <Guid>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? ((Guid?)val).ToString() : string.Empty); } //float else if (pInfos[i].PropertyType.FullName == typeof(float).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToSingle(val) : 0); } //float||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <float>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToSingle(val) : 0); } //double else if (pInfos[i].PropertyType.FullName == typeof(double).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToDouble(val) : 0); } //double||null else if (pInfos[i].PropertyType.FullName == typeof(Nullable <double>).FullName) { entryArr[i] = new HashEntry(pInfos[i].Name, val != null ? Convert.ToDouble(val) : 0); } } return(entryArr); }
public static void RunProcess(Object stateInfo) { List <Log> logs = new List <Log>(); StreamEntry[] entries = db.StreamRead("Stream:Customer", position); foreach (var entry in entries) { string entityKey = ((NameValueEntry)entry.Values.GetValue(0)).Value.ToString(); string logKey = ((NameValueEntry)entry.Values.GetValue(1)).Value.ToString(); Log logItem = new Log(); logs.Add(logItem); logItem.Current = db.HashGetAll(entityKey); //search for the key and get the most up to date one var keys = server.Keys(pattern: $"log:{entityKey}*", pageSize: 10000); string previousSnapshotKey = ""; List <string> keyList = keys.Select(k => k.ToString()).OrderByDescending(o => o.ToString()).ToList(); foreach (var k in keyList) { if (String.Compare(logKey, k) > 0) { //logKey the most up to date record. //we will take the one below previousSnapshotKey = k; break; } } #region New Record if (previousSnapshotKey == String.Empty) { //it is a new record. foreach (var item in logItem.Current) { logItem.Added.Add(item.Name); } Console.WriteLine("== Added Items =="); foreach (var d in logItem.Added) { Console.WriteLine($"{d}={logItem.Current.ToDictionary()[d]}"); } position = entry.Id; continue; } #endregion logItem.Snapshot = db.HashGetAll(previousSnapshotKey); #region Added/Updated Action foreach (var item in logItem.Current) { HashEntry snapshotItem = Array.Find(logItem.Snapshot, s => s.Name == item.Name); if (snapshotItem != null) { //key exists if (snapshotItem.Value != item.Value) { logItem.Updated.Add(item.Name); //value has been updated } } else { //key not exists. It must be new field logItem.Added.Add(item.Name); //new value } } Console.WriteLine("== Updated Items =="); foreach (var d in logItem.Updated) { Console.WriteLine($"{d}={logItem.Current.ToDictionary()[d]}"); } #endregion #region Deleted Action foreach (var item in logItem.Snapshot) { if (!Array.Exists(logItem.Current, a => a.Name == item.Name)) { //new set has no such key logItem.Removed.Add(item.Name); } } #endregion position = entry.Id; } }
public void Update() { UpdateVoxelDistances(Camera.main.transform.position); if (!m_ActiveReconstruction) { return; } // Fill in the data to draw the point cloud. if (Frame.PointCloud.IsUpdatedThisFrame) { // Copy the point cloud points for mesh verticies. NumberOfPoints += Frame.PointCloud.PointCount; for (int i = 0; i < Frame.PointCloud.PointCount; i++) { UnityEngine.Profiling.Profiler.BeginSample("PointCloud"); m_Points[i] = Frame.PointCloud.GetPoint(i); detected_point = Frame.PointCloud.GetPoint(i); int hash = m_Reconstructor.GetSpatialHashing().GetHash(detected_point, m_Reconstructor.GetSpatialHashing().GetScale(), m_Reconstructor.GetSpatialHashing().GetHashTableSize()); if (detected_point.w < Constants.CONFIDENCE_THRESHOLD) { continue; } if (Vector3.Distance(Camera.main.transform.position, detected_point) > m_Reconstructor.GetSpatialHashing().GetMaxReconstructionDistance()) { continue; } if (!m_Reconstructor.GetSpatialHashing().Contains(hash)) { //Debug.Log("Reconstructor" + ": " + "Point > " + m_Points[i].ToString("G4") + ", NEW Hash: " + hash + ", Size: " + reconstructor.spatialHashing.Size()); Vector3 point = Optimization.ScalePoint(detected_point, m_Reconstructor.GetSpatialHashing().GetScale()); pose.position = point; pose.rotation = zeroQuaternion; Anchor anchor = Session.CreateAnchor(pose); GameObject voxelObject = Instantiate(m_VoxelPrefab, pose.position, pose.rotation); float voxelSize = 1.00f / m_Reconstructor.GetSpatialHashing().GetScale(); voxelObject.GetComponent <Renderer>().enabled = m_ActiveRenderer; voxelObject.transform.localScale = new Vector3(voxelSize, voxelSize, voxelSize); GameObject parentVoxelGameObject = new GameObject("_voxel_" + hash); GameObject lodContainer = new GameObject("_levelOfDetail_0"); voxelObject.transform.SetParent(lodContainer.transform); lodContainer.transform.SetParent(anchor.transform); anchor.transform.SetParent(parentVoxelGameObject.transform); parentVoxelGameObject.transform.SetParent(m_AllVoxels.transform); m_TempHashEntry = m_Reconstructor.GetSpatialHashing().CreateHash(detected_point, new Voxel(voxelObject), lodContainer); m_Reconstructor.GetSpatialHashing().AddToTable(m_TempHashEntry); } else { m_TempHashEntry = (HashEntry)m_Reconstructor.GetSpatialHashing().GetFromTable(hash); m_Reconstructor.GetSpatialHashing().AddPointToEntry(detected_point); } UnityEngine.Profiling.Profiler.EndSample(); if (DebugText.Instance.UpdateDistances) { m_Reconstructor.GetSpatialHashing().UpdateDistanceResolution(m_TempHashEntry); } if (!m_ActiveRenderer) { GameObject gameObject = GameObject.Find("_voxel_" + hash); foreach (Renderer r in gameObject.GetComponentsInChildren <Renderer>()) { r.enabled = false; } } CheckPointCloseToPlanes(m_TempHashEntry); } if (m_ActiveRenderer) { DrawPointCloud(); } else { m_Mesh.Clear(); } } GetCubeInfoOnTouch(); }
/// <summary> /// Gets the locale of the file. The actual values of the enum are Windows LANGID values, but /// files are most commonly set to 0 (default or neutral locale). /// </summary> /// <returns>The locale.</returns> public LocaleID GetLocale() { return(HashEntry.GetLocalizationID()); }
public bool setHashs(string hash, List <KeyValuePair <string, object> > par, IDBTableDesc desc) { if (_conn == null) { // error: without _conn // important: don't log par, or may expose sensitive data!!! Debug.logger.log(LogType.LOG_ERR, "DBRedisDB name[" + this.name + "] setHashs hash[" + hash + "] without connection!"); return(false); } IDatabase db = _conn.GetDatabase(); bool ret = true; HashEntry[] hashs = new HashEntry[par.Count]; for (int i = 0; i < par.Count; ++i) { AEDBDataType dt = desc.getDataType(par[i].Key); switch (dt) { case AEDBDataType.ADDT_INT: hashs[i] = new HashEntry(par[i].Key, (int)par[i].Value); break; case AEDBDataType.ADDT_UINT: hashs[i] = new HashEntry(par[i].Key, (uint)par[i].Value); break; case AEDBDataType.ADDT_FLOAT: hashs[i] = new HashEntry(par[i].Key, (float)par[i].Value); break; case AEDBDataType.ADDT_LONG: hashs[i] = new HashEntry(par[i].Key, (long)par[i].Value); break; case AEDBDataType.ADDT_ULONG: hashs[i] = new HashEntry(par[i].Key, (ulong)par[i].Value); break; case AEDBDataType.ADDT_DOUBLE: hashs[i] = new HashEntry(par[i].Key, (double)par[i].Value); break; case AEDBDataType.ADDT_BINARY: { byte[] objBytes = AEDBHelper.serializeObject(par[i].Value); hashs[i] = new HashEntry(par[i].Key, objBytes); } break; //case AEDBDataType.ADDT_STRING: // deault is string default: hashs[i] = new HashEntry(par[i].Key, (string)par[i].Value); break; } } if (_expireTime > 0) { db.HashSet(hash, hashs); db.KeyExpire(hash, TimeSpan.FromSeconds(_expireTime)); } else { db.HashSet(hash, hashs); } return(ret); }
private async Task SetCacheEntities(IReadOnlyList <Entity> entities) { IRedisDatabase db = GetCache(); ITransaction trans = db.Database.CreateTransaction(); { string key = CacheUtils.BuildEntities(Nuid.New(Identity, Identity)); HashEntry[] hashFields = new HashEntry[entities.Count]; for (int i = 0; i < entities.Count; i++) { hashFields[i] = new HashEntry(entities[i].Id.Unique, entities[i].Type); } Task _ = trans.HashSetAsync(key, hashFields); } { foreach (Entity entity in entities) { EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type); if (entity_prefab == null) { continue; } string fields_key = CacheUtils.BuildFields(entity.Id); Field[] fields = entity.GetFields(); List <HashEntry> cache_fields = new List <HashEntry>(); for (int i = 0; i < fields.Length; i++) { FieldPrefab field_prefab = entity_prefab.fields[fields[i].Name]; if (field_prefab == null) { continue; } string field_value = ""; switch (field_prefab.type) { case VarType.Bool: field_value = JsonUtils.ToJson(fields[i].Get <bool>()); break; case VarType.Int: field_value = JsonUtils.ToJson(fields[i].Get <int>()); break; case VarType.Long: field_value = JsonUtils.ToJson(fields[i].Get <long>()); break; case VarType.Float: field_value = JsonUtils.ToJson(fields[i].Get <float>()); break; case VarType.String: field_value = JsonUtils.ToJson(fields[i].Get <string>()); break; case VarType.Nuid: field_value = JsonUtils.ToJson(fields[i].Get <Nuid>()); break; case VarType.List: field_value = JsonUtils.ToJson(fields[i].Get <NList>()); break; default: break; } cache_fields.Add(new HashEntry(fields[i].Name, field_value)); } Task _ = trans.HashSetAsync(fields_key, cache_fields.ToArray()); Table[] tables = entity.GetTables(); foreach (Table table in tables) { string table_key = CacheUtils.BuildTable(entity.Id, table.GetName()); TablePrefab table_prefab = entity_prefab.tables[table.GetName()]; if (table_prefab == null) { continue; } List <HashEntry> cache_key_values = new List <HashEntry>(); void SetCacheKeyValue <TPrimaryKey>() { Table <TPrimaryKey> t = table as Table <TPrimaryKey>; IReadOnlyList <TPrimaryKey> keys = t.GetPrimaryKeys(); foreach (TPrimaryKey key in keys) { string json = JsonUtils.ToJson(t.GetKeyValue(key)); cache_key_values.Add(new HashEntry(key.ToString(), json)); } } switch (table_prefab.primary_key.type) { case VarType.Bool: SetCacheKeyValue <bool>(); break; case VarType.Int: SetCacheKeyValue <int>(); break; case VarType.Long: SetCacheKeyValue <long>(); break; case VarType.Float: SetCacheKeyValue <float>(); break; case VarType.String: SetCacheKeyValue <string>(); break; case VarType.Nuid: SetCacheKeyValue <Nuid>(); break; default: break; } Task __ = trans.HashSetAsync(table_key, cache_key_values.ToArray()); } } bool redis_execute = await trans.ExecuteAsync(); if (!redis_execute) { throw new Exception("trans ExecuteAsync ERROR!!"); } } }
public async Task <T> Save(T instance, bool saveChangedOnly = true) { var serialKey = _storageKeyGenerator.GetSerialKey(_typeDefinition); var clusterIndexKey = _storageKeyGenerator.GetClusteredIndexKey(_typeDefinition); var _val = _valueConverter.ResolveId(_typeDefinition, instance); RedisValue id = _val.Item1; bool wasIdSet = _val.Item2; RedisKey key; var existingIndexes = new RedisKey[0]; var existingRecord = new HashEntry[0]; long serial = -1; if (!wasIdSet) { // this is a new object so we need to add it to the clustered index... serial = await _database.StringIncrementAsync(serialKey).ConfigureAwait(false); // guid ids are auto generated and not null if (id.IsNull) { id = serial; } // and set the id on the object _typeDefinition.Accessor[instance, _typeDefinition.PrimaryKey.Name] = _valueConverter.ToObject(id, _typeDefinition.PrimaryKey.Type); key = _storageKeyGenerator.GetKey(_typeDefinition, id); } else { string rawIndexes = null; key = _storageKeyGenerator.GetKey(_typeDefinition, id); if (saveChangedOnly) { existingRecord = await _database.HashGetAllAsync(key).ConfigureAwait(false); rawIndexes = existingRecord.FirstOrDefault(h => h.Name == Constants.RoidHashFieldIndexes).Value; } else { rawIndexes = await _database.HashGetAsync(key, Constants.RoidHashFieldIndexes).ConfigureAwait(false); } // if rawIndexes is null, that means we have not yet saved the object // id is user provided in this case hence we need to add it to the clustered index if (string.IsNullOrWhiteSpace(rawIndexes)) { serial = await _database.StringIncrementAsync(serialKey).ConfigureAwait(false); } else { existingIndexes = rawIndexes.Split(new[] { Constants.Separator }, StringSplitOptions.RemoveEmptyEntries) .Select(i => (RedisKey)i) .ToArray(); } } bool isNew = serial != -1; var hash = _mapper.HashFor(_typeDefinition, instance, isNew, existingRecord); var indexes = _indexer.GetIndexes(_typeDefinition, hash); var indexesToRemove = existingIndexes.Where(i => !indexes.Contains(i)).ToArray(); var indexesToAdd = indexes.Where(i => !existingIndexes.Contains(i)).ToArray(); #region save to redis var keyString = (string)key; var txn = _database.CreateTransaction(); #pragma warning disable CS4014 txn.HashSetAsync(key, hash.ToArray()); if (isNew) { txn.SortedSetAddAsync(clusterIndexKey, new[] { new SortedSetEntry(keyString, serial) }); } foreach (var index in indexesToAdd) { txn.SetAddAsync(index, keyString); } foreach (var index in indexesToRemove) { txn.SetRemoveAsync(index, keyString); } #pragma warning restore CS4014 if (!await txn.ExecuteAsync().ConfigureAwait(false)) { throw new RoidException("Failed to commit the transaction"); } #endregion save to redis return(instance); }
private static HashEntry GetHashEntry(Type enumType) { HashEntry hashEntry = (HashEntry)fieldInfoHash[enumType]; if (hashEntry == null) { // To reduce the workingset we clear the hashtable when a threshold number of elements are inserted. if (fieldInfoHash.Count > maxHashElements) fieldInfoHash.Clear(); ulong[] values = null; String[] names = null; BCLDebug.Assert(enumType.BaseType == typeof(Enum), "Base type must of type Enum"); if (enumType.BaseType == typeof(Enum)) InternalGetEnumValues(enumType, ref values, ref names); // If we switch over to EnumBuilder, this code path will be required. else { // fall back on reflection for odd cases FieldInfo[] flds = enumType.GetFields(BindingFlags.Static | BindingFlags.Public); values = new ulong[flds.Length]; names = new String[flds.Length]; for (int i = 0; i < flds.Length; i++) { names[i] = flds[i].Name; values[i] = ToUInt64(flds[i].GetValue(null)); } // Insertion Sort these values in ascending order. // We use this O(n^2) algorithm, but it turns out that most of the time the elements are already in sorted order and // the common case performance will be faster than quick sorting this. for (int i = 1; i < values.Length; i++) { int j = i; String tempStr = names[i]; ulong val = values[i]; bool exchanged = false; // Since the elements are sorted we only need to do one comparision, we keep the check for j inside the loop. while (values[j - 1] > val) { names[j] = names[j - 1]; values[j] = values[j - 1]; j--; exchanged = true; if (j == 0) break; } if (exchanged) { names[j] = tempStr; values[j] = val; } } } hashEntry = new HashEntry(names, values); fieldInfoHash[enumType] = hashEntry; } return hashEntry; }
/** * Creates a ReferenceEntry instead of a HashEntry. * * @param next the next entry in sequence * @param hashCode the hash code to use * @param key the key to store * @param value the value to store * @return the newly created entry */ protected override HashEntry createEntry(HashEntry next, int hashCode, Object key, Object value) { return(new ReferenceEntry(this, next, hashCode, key, value)); }
public void NeighborhoodSearch(Vector3d[] particles, Vector3d[] boundary) { if (particles.Length > NumParticles) { throw new ArgumentException("Particle array length larger than expected"); } //double invCellSize = 1.0 / CellSize; double r2 = CellSize * CellSize; for (int i = 0; i < NumParticles; i++) { AddToGrid(i, particles[i]); } for (int i = 0; i < boundary.Length; i++) { AddToGrid(NumParticles + i, boundary[i]); } for (int i = 0; i < NumParticles; i++) { Vector3d p0 = particles[i]; NumNeighbors[i] = 0; int cellPos1, cellPos2, cellPos3; Floor(particles[i], out cellPos1, out cellPos2, out cellPos3); for (int j = 0; j < 27; j++) { int cellPos = Hash(cellPos1 + Indexes[j, 0], cellPos2 + Indexes[j, 1], cellPos3 + Indexes[j, 2]); HashEntry entry = null; GridMap.TryGetValue(cellPos, out entry); if (entry != null && entry.TimeStamp == CurrentTimeStamp) { int count = entry.Indices.Count; for (int m = 0; m < count; m++) { int pi = entry.Indices[m]; if (pi == i) { continue; } double dist2 = 0.0; if (pi < NumParticles) { Vector3d p; p.x = p0.x - particles[pi].x; p.y = p0.y - particles[pi].y; p.z = p0.z - particles[pi].z; dist2 = p.x * p.x + p.y * p.y + p.z * p.z; } else { int bi = pi - NumParticles; Vector3d p; p.x = p0.x - boundary[bi].x; p.y = p0.y - boundary[bi].y; p.z = p0.z - boundary[bi].z; dist2 = p.x * p.x + p.y * p.y + p.z * p.z; } if (dist2 < r2) { if (NumNeighbors[i] < MaxNeighbors) { Neighbors[i, NumNeighbors[i]++] = pi; } else { throw new InvalidOperationException("too many neighbors detected"); } } } } } } //End of function }
/// <summary> /// Gets the platform that the file is meant for. A 0 indicates default or platform-neutral. /// </summary> /// <returns>The platform.</returns> public ushort GetPlatform() { return(HashEntry.GetPlatformID()); }
/// <summary> /// Gets the user data. /// </summary> /// <returns>The user data.</returns> /// <param name="email">Email.</param> public User getUserHashData(string email) { //check if email is verifyed in Redis int emailVerifyResponse = emailVerify(email); switch (emailVerifyResponse) { case 1: //no email exists return(null); case -1: //empty field email return(null); case -2: //incorrect email format return(null); case -3: //YAY email exists //create key for Redis call var key = "user:"******"name") { getUser.Name = userKey.Value.ToString(); } else if (userKey.Name.ToString() == "email") { getUser.Email = userKey.Value.ToString(); } else if (userKey.Name.ToString() == "age") { getUser.Age = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "weight") { getUser.Weight = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "bench") { getUser.Bench = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "squat") { getUser.Squat = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "snatch") { getUser.Snatch = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "deadlift") { getUser.Deadlift = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "cleanjerk") { getUser.CleanAndJerk = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "workoutsCompleted") { getUser.WorkoutsCompleted = Int16.Parse(userKey.Value.ToString()); } else if (userKey.Name.ToString() == "password") { getUser.Password = userKey.Value.ToString(); } } string getResponse = string.Empty; for (int i = 0; i < data.Length; i++) { if (i == data.Length - 1) { getResponse = getResponse + data[i]; } else { getResponse = getResponse + data[i] + ","; } } return(getUser); case -4: default: return(null); } }
public void OnExecuted(RedisCommand command, ref object result, RedisKey[] involvedKeys = null) { if (CanBeExecuted(involvedKeys)) { if (result != null && result.GetType() != typeof(bool) && result.GetType() != typeof(int) && result.GetType() != typeof(long)) { bool isScanResult = command == RedisCommand.SCAN || command == RedisCommand.HSCAN || command == RedisCommand.SSCAN || command == RedisCommand.ZSCAN; object scanValues = null; if (isScanResult) scanValues = result.GetType() .GetField("Values", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance) .GetValue(result); if (result.GetType() == typeof(RedisValue)) { byte[] valueBlob = (RedisValue)result; RedisValueCompressor.Compressor.Decompress(ref valueBlob); if (valueBlob != null && valueBlob.Length > 0) result = (RedisValue)Encoding.UTF8.GetString(valueBlob); } else if (result.GetType() == typeof(RedisValue[]) || (command == RedisCommand.SCAN || command == RedisCommand.SSCAN)) { RedisValue[] values; if (!isScanResult) values = (RedisValue[])result; else values = (RedisValue[])scanValues; for (int i = 0; i < values.Length; i++) { byte[] valueBlob = values[i]; RedisValueCompressor.Compressor.Decompress(ref valueBlob); values[i] = (RedisValue)valueBlob; } } else if (result.GetType() == typeof(SortedSetEntry)) { SortedSetEntry source = (SortedSetEntry)result; byte[] valueBlob = source.Element; RedisValueCompressor.Compressor.Decompress(ref valueBlob); result = new SortedSetEntry((RedisValue)valueBlob, source.Score); } else if (result.GetType() == typeof(SortedSetEntry[]) || command == RedisCommand.ZSCAN) { SortedSetEntry[] entries; if (!isScanResult) entries = (SortedSetEntry[])result; else entries = (SortedSetEntry[])scanValues; for (int i = 0; i < entries.Length; i += 2) { SortedSetEntry source = (SortedSetEntry)entries[i]; byte[] valueBlob = source.Element; RedisValueCompressor.Compressor.Decompress(ref valueBlob); entries[i] = new SortedSetEntry((RedisValue)valueBlob, source.Score); } } else if (result.GetType() == typeof(HashEntry)) { HashEntry source = (HashEntry)result; byte[] valueBlob = source.Value; RedisValueCompressor.Compressor.Decompress(ref valueBlob); result = new HashEntry(source.Name, (RedisValue)valueBlob); } else if (result.GetType() == typeof(HashEntry[]) || command == RedisCommand.HSCAN) { HashEntry[] entries; if (!isScanResult) entries = (HashEntry[])result; else // TODO: Not the best solution... But I need to investigate further how to improve StackExchange.Redis // to get these values directly... entries = (HashEntry[])scanValues; for (int i = 0; i < entries.Length; i++) { HashEntry source = entries[i]; byte[] valueBlob = source.Value; RedisValueCompressor.Compressor.Decompress(ref valueBlob); entries[i] = new HashEntry(source.Name, (RedisValue)valueBlob); } } } } }
public async Task CheckTheUserForMessage(ApplicationUser user, int ChannelId, string channelName) { if (user.UserName == "haha" || user.UserName == "haha2") { return; } //Console.WriteLine(user.UserId); var sent_message_count = 0; var sent_email_body = ""; var last_seen_time = DateTime.Now; List <TextModel> message_list = new List <TextModel>(); // last seen is updated ondisconnectedasync RedisValue test_data; try { test_data = _redis_db.HashGet("LastSeen" + ChannelId, user.Id); } catch { return; } // Console.WriteLine("Plz: " + test_data); System.Diagnostics.Debug.WriteLine(test_data); last_seen_time = Convert.ToDateTime(test_data); System.Diagnostics.Debug.WriteLine(last_seen_time); // Get all the messages in that channel // Compare them with last seen, and append them to list var messages = _redis_db.ListRange(ChannelId.ToString(), 0, -1); foreach (var message in messages) { TextModel text = JsonConvert.DeserializeObject <TextModel>(message); var sent_time = Convert.ToDateTime(text.SentTime); if (sent_time > last_seen_time) { // Add message to bulk email content sent_email_body += text.Content; // Add message to list message_list.Add(text); // Increment the counter sent_message_count++; } } // If no message is fetched no need to send a mail if (sent_message_count == 0) { System.Diagnostics.Debug.WriteLine("No need to send a mail."); } else { var finalized_mail_body = GetFormattedMessage(message_list, user, channelName); // Send the email to user await _emailSender.SendEmailAsync(user.Email, "Channel Bulk Mail Feed : " + channelName, finalized_mail_body); // Set last seen for this person in this channel to this message HashEntry entry = new HashEntry(user.Id.ToString(), DateTime.Now.ToString()); HashEntry[] arr = new HashEntry[1]; arr[0] = entry; _redis_db.HashSet("LastSeen" + ChannelId.ToString(), arr); } }
public void HashSet_1() { HashEntry[] hashFields = new HashEntry[0]; wrapper.HashSet("key", hashFields, CommandFlags.HighPriority); mock.Verify(_ => _.HashSet("prefix:key", hashFields, CommandFlags.HighPriority)); }
public void TransferLock(string address) { IDatabase db = Business.RedisConnection.Instance.GetDatabase(); HashEntry[] hashFields = new HashEntry[3]; hashFields[0] = new HashEntry("MasterAccessionNo", this.MasterAccessionNo); hashFields[1] = new HashEntry("Address", address); hashFields[2] = new HashEntry("TimeAquired", DateTime.Now.ToString()); db.HashSet(this.HashKey, hashFields); this.m_Address = address; this.m_TimeAquired = DateTime.Now; this.NotifyPropertyChanged(string.Empty); }
public void DeleteHashValue(HashEntry entry, RedisKeyObject hashKey) { Task.Run(async () => await DeleteHashValueAsync(entry, hashKey)).Wait(); }
public abstract Task DeleteHashValueAsync(HashEntry entry, RedisKeyObject hashKey, CancellationToken token = default(CancellationToken));
public void Intercept(IInvocation invocation) { var prop = ((IProxyTargetAccessor)invocation.Proxy).GetTargetPropertyInfo(); var hashKey = new RedisKeyObject(prop, _commonData.Id); _commonData.RedisObjectManager.RedisBackup?.RestoreHash(_commonData.RedisDatabase, hashKey); // We will need the Original value no matter what var accessor = (IProxyTargetAccessor)invocation.Proxy; var original = (accessor.DynProxyGetTarget() as IDictionary)?[invocation.Arguments[0]]; if (original == null) return; object dictKey = null, dictValue = null; // Determine if this is a KeyValuePair or a 2 argument if (invocation.Arguments.Length == 2) { dictKey = invocation.Arguments[0]; dictValue = invocation.Arguments[1]; } else { var valuePairType = invocation.Arguments[0].GetType(); if (valuePairType.Name.StartsWith("KeyValuePair", StringComparison.Ordinal)) { dictKey = valuePairType.GetProperty("Key").GetValue(invocation.Arguments[0]); dictValue = valuePairType.GetProperty("Value").GetValue(invocation.Arguments[0]); } } if (dictKey == null || dictValue == null) { throw new NullReferenceException("Key or Value cannot be Null"); } var valueRedis = dictValue as IRedisObject; if (valueRedis != null) { RedisKeyObject key; if (!(dictValue is IProxyTargetAccessor)) { //var proxy = CreateProxy(valueRedis, out key); var proxy = valueRedis.CreateProxy(_commonData, out key); invocation.Arguments[1] = proxy; dictValue = proxy; } else { key = new RedisKeyObject(valueRedis.GetType(), string.Empty); _commonData.RedisDatabase.GenerateId(key, dictValue, _commonData.RedisObjectManager.RedisBackup); } if (_commonData.Processing) { invocation.Proceed(); return; } // TODO we will need to try to remove the old RedisObject var hashEntry = new HashEntry((string)dictKey, key.RedisKey); _commonData.RedisObjectManager.RedisBackup?.UpdateHashValue(hashEntry, hashKey); _commonData.RedisDatabase.HashSet(hashKey.RedisKey, hashEntry.Name, hashEntry.Value); _commonData.RedisObjectManager.SaveObject(dictValue, key.Id, _commonData.RedisDatabase); } else { if (_commonData.Processing) { invocation.Proceed(); return; } var hashValue = new HashEntry((string)dictKey, (RedisValue)dictValue); _commonData.RedisObjectManager.RedisBackup?.UpdateHashValue(hashValue, hashKey); _commonData.RedisDatabase.HashSet(hashKey.RedisKey, hashValue.Name, hashValue.Value); } invocation.Proceed(); }
private void GetHashEntry(int index, out HashEntry h) { h.Name1 = hashTable[index * 4 + 0]; h.Name2 = hashTable[index * 4 + 1]; h.BlockIndex = hashTable[index * 4 + 3]; }
private static HashEntry GetHashEntry(Type enumType) { HashEntry entry = (HashEntry) fieldInfoHash[enumType]; if (entry == null) { if (fieldInfoHash.Count > 100) { fieldInfoHash.Clear(); } ulong[] values = null; string[] names = null; if (enumType.BaseType == typeof(Enum)) { InternalGetEnumValues(enumType, ref values, ref names); } else { FieldInfo[] fields = enumType.GetFields(BindingFlags.Public | BindingFlags.Static); values = new ulong[fields.Length]; names = new string[fields.Length]; for (int i = 0; i < fields.Length; i++) { names[i] = fields[i].Name; values[i] = ToUInt64(fields[i].GetValue(null)); } for (int j = 1; j < values.Length; j++) { int index = j; string str = names[j]; ulong num4 = values[j]; bool flag = false; while (values[index - 1] > num4) { names[index] = names[index - 1]; values[index] = values[index - 1]; index--; flag = true; if (index == 0) { break; } } if (flag) { names[index] = str; values[index] = num4; } } } entry = new HashEntry(names, values); fieldInfoHash[enumType] = entry; } return entry; }
/** * Adds an entry into this map, maintaining insertion order. * <p> * This implementation adds the entry to the data storage table and * to the end of the linked list. * * @param entry the entry to add * @param hashIndex the index into the data array to store at */ protected override void addEntry(HashEntry entry, int hashIndex) { LinkEntry link = (LinkEntry)entry; link.after = header; link.before = header.before; header.before.after = link; header.before = link; data[hashIndex] = entry; }
public void Intercept(IInvocation invocation) { var prop = ((IProxyTargetAccessor)invocation.Proxy).GetTargetPropertyInfo(); var hashKey = new RedisKeyObject(prop, _commonData.Id); _commonData.RedisObjectManager.RedisBackup?.RestoreHash(_commonData.RedisDatabase, hashKey); object dictKey = null, dictValue = null; // Determine if this is a KeyValuePair or a 2 argument if (invocation.Arguments.Length == 2) { dictKey = invocation.Arguments[0]; dictValue = invocation.Arguments[1]; } else { var valuePairType = invocation.Arguments[0].GetType(); if (valuePairType.Name.StartsWith("KeyValuePair", StringComparison.Ordinal)) { dictKey = valuePairType.GetProperty("Key").GetValue(invocation.Arguments[0]); dictValue = valuePairType.GetProperty("Value").GetValue(invocation.Arguments[0]); } } if (dictKey == null || dictValue == null) { throw new NullReferenceException("Key or Value cannot be null"); } var containsKeyMethod = invocation.Proxy.GetType().GetMethod("ContainsKey", new[] { dictKey.GetType() }); if ((bool)containsKeyMethod.Invoke(invocation.Proxy, new[] { dictKey })) { invocation.Proceed(); return; } var redisObject = dictValue as IRedisObject; if (redisObject != null) { RedisKeyObject key; if (!(dictValue is IProxyTargetAccessor)) { var proxy = redisObject.CreateProxy(_commonData, out key); invocation.Arguments[1] = proxy; dictValue = proxy; } else { key = new RedisKeyObject(redisObject.GetType()); _commonData.RedisDatabase.GenerateId(key, dictValue, _commonData.RedisObjectManager.RedisBackup); } if (_commonData.Processing) { invocation.Proceed(); return; } HashEntry hashEntry; if (dictKey is RedisValue) { hashEntry = new HashEntry((RedisValue) dictKey, key.RedisKey); } else { RedisValue redisKey; if (!_commonData.RedisObjectManager.TryConvertToRedisValue(dictKey, out redisKey)) { throw new Exception("Invalid Key Type..."); } hashEntry = new HashEntry(redisKey, key.RedisKey); } _commonData.RedisObjectManager.RedisBackup?.UpdateHashValue(hashEntry, hashKey); _commonData.RedisDatabase.HashSet(hashKey.RedisKey, hashEntry.Name, hashEntry.Value); _commonData.RedisObjectManager.SaveObject(dictValue, key.Id, _commonData.RedisDatabase); } else { if (_commonData.Processing) { invocation.Proceed(); return; } // Converter can get rid of this too RedisValue newDictValue; if (!(dictValue is RedisValue)) { if (!_commonData.RedisObjectManager.TryConvertToRedisValue(dictValue, out newDictValue)) { throw new Exception("Cannot convert to RedisValue"); } } else { newDictValue = (RedisValue)dictValue; } HashEntry hashEntry; if (dictKey is RedisValue) { hashEntry = new HashEntry((RedisValue) dictKey, newDictValue); } else { RedisValue redisKey; if (!_commonData.RedisObjectManager.TryConvertToRedisValue(dictKey, out redisKey)) { throw new Exception("Cannot convert to RedisValue"); } hashEntry = new HashEntry(redisKey, newDictValue); } _commonData.RedisObjectManager.RedisBackup?.UpdateHashValue(hashEntry, hashKey); _commonData.RedisDatabase.HashSet(hashKey.RedisKey, hashEntry.Name, hashEntry.Value); } invocation.Proceed(); }
/** * Creates an entry to store the data. * This implementation creates an IdentityEntry instance. * * @param next the next entry in sequence * @param hashCode the hash code to use * @param key the key to store * @param value the value to store * @return the newly created entry */ protected override HashEntry createEntry(HashEntry next, int hashCode, Object key, Object value) { return new IdentityEntry(next, hashCode, key, value); }
/// <summary> /// Instantiates a new instance of the RedisSessionStateItemCollection class with data from /// Redis /// </summary> /// <param name="redisHashData">An array of keys to values from the redis hash</param> /// <param name="redisConnName">The name of the connection from the redis connection wrapper</param> public RedisSessionStateItemCollection( HashEntry[] redisHashData, string redisConnName, byte constructorSignatureDifferentiator) { int byteDataTotal = 0; int concLevel = RedisSessionConfig.SessionAccessConcurrencyLevel; if (concLevel < 1) { concLevel = 1; } int numItems = 0; if (redisHashData != null) { numItems = redisHashData.Length; } // To match ASP.NET behavior, dictionaries should match keys case insensitively this.Items = new ConcurrentDictionary<string, object>(concLevel, numItems, StringComparer.InvariantCultureIgnoreCase); this.SerializedRawData = new ConcurrentDictionary<string, string>(concLevel, numItems, StringComparer.InvariantCultureIgnoreCase); if (redisHashData != null) { foreach (var sessDataEntry in redisHashData) { string hashItemKey = sessDataEntry.Name.ToString(); string hashItemValue = sessDataEntry.Value.ToString(); if (this.SerializedRawData.TryAdd( hashItemKey, hashItemValue)) { this.Items.TryAdd( hashItemKey, new NotYetDeserializedPlaceholderValue()); } byteDataTotal += hashItemValue.Length; } } // To match ASP.NET behavior, dictionaries should match keys case insensitively this.ChangedKeysDict = new ConcurrentDictionary<string, ActionAndValue>(StringComparer.InvariantCultureIgnoreCase); if (byteDataTotal != 0 && !string.IsNullOrEmpty(redisConnName) && RedisConnectionConfig.LogRedisSessionSize != null) { RedisConnectionConfig.LogRedisSessionSize(redisConnName, byteDataTotal); } this.cereal = RedisSerializationConfig.SessionDataSerializer; if (byteDataTotal > RedisConnectionConfig.MaxSessionByteSize) { RedisConnectionConfig.RedisSessionSizeExceededHandler(this, byteDataTotal); } }
public void TestSetPairs() // http://redis.io/commands/hmset { using (var muxer = Config.GetUnsecuredConnection()) { var conn = muxer.GetDatabase(9); conn.KeyDeleteAsync("hashkey"); var result0 = conn.HashGetAllAsync("hashkey"); var data = new HashEntry[] { new HashEntry("foo", Encoding.UTF8.GetBytes("abc")), new HashEntry("bar", Encoding.UTF8.GetBytes("def")) }; conn.HashSetAsync("hashkey", data); var result1 = conn.HashGetAllAsync("hashkey"); Assert.AreEqual(0, result0.Result.Length); var result = result1.Result.ToStringDictionary(); Assert.AreEqual(2, result.Count); Assert.AreEqual("abc", result["foo"]); Assert.AreEqual("def", result["bar"]); } }
public override void Load(HashSet<Request> requests) { lock (this) { RedisValue[] identities = new RedisValue[requests.Count]; HashEntry[] items = new HashEntry[requests.Count]; int i = 0; foreach (var request in requests) { identities[i] = request.Identity; items[i] = new HashEntry(request.Identity, JsonConvert.SerializeObject(request)); ++i; } Db.SetAdd(SetKey, identities); Db.ListRightPush(QueueKey, identities); Db.HashSet(ItemKey, items); } }
/// <summary> /// convert hashEntry array to Dictionary /// </summary> /// <param name="entries">HashEntry[]</param> /// <returns>IDictionary{string, string}</returns> protected IDictionary<string, string> ConvertToDictionaryString(HashEntry[] entries) { var stringMap = new Dictionary<string, string>(); if (entries != null) { foreach (var entry in entries) { stringMap.Add(entry.Name, entry.Value.ToString()); } } return stringMap; }
/** * Removes an entry from the map and the linked list. * <p> * This implementation removes the entry from the linked list chain, then * calls the superclass implementation. * * @param entry the entry to remove * @param hashIndex the index into the data structure * @param previous the previous entry in the chain */ protected override void removeEntry(HashEntry entry, int hashIndex, HashEntry previous) { LinkEntry link = (LinkEntry)entry; link.before.after = link.after; link.after.before = link.before; link.after = null; link.before = null; base.removeEntry(entry, hashIndex, previous); }
private void TryHashSet() { IDatabase db = Business.RedisConnection.Instance.GetDatabase(); HashEntry[] hashFields = new HashEntry[3]; hashFields[0] = new HashEntry("MasterAccessionNo", this.m_MasterAccessionNo); hashFields[1] = new HashEntry("Address", UI.AppMessaging.AccessionLockMessage.GetMyAddress()); hashFields[2] = new HashEntry("TimeAquired", DateTime.Now.ToString()); var transaction = db.CreateTransaction(); transaction.AddCondition(Condition.HashNotExists(this.HashKey, "MasterAccessionNo")); transaction.HashSetAsync(this.HashKey, hashFields); transaction.SetAddAsync("AccessionLocks", this.HashKey); bool committed = transaction.Execute(); }
protected internal IdentityEntry(HashEntry next, int hashCode, Object key, Object value) : base(next, hashCode, key, value) { }
public AccessionLock(HashEntry[] hashEntries) { this.m_MasterAccessionNo = hashEntries[0].Value; this.m_Address = hashEntries[1].Value; this.m_TimeAquired = DateTime.Parse(hashEntries[2].Value); }
public static HashEntry WithName(HashEntry[] hash, string name) { return hash.Single(h => h.Name == name); }
/// <summary> /// 批量导入 /// </summary> /// <param name="requests">请求对象</param> public override void Reload(ICollection <Request> requests) { var action = new Action(() => { lock (_locker) { int batchCount = BatchCount; var count = requests.Count; int cacheSize = count > batchCount ? batchCount : count; RedisValue[] identities = new RedisValue[cacheSize]; HashEntry[] items = new HashEntry[cacheSize]; int i = 0; int j = count % batchCount; int n = count / batchCount; foreach (var request in requests) { identities[i] = request.GetIdentity(); items[i] = new HashEntry(request.GetIdentity(), JsonConvert.SerializeObject(request)); ++i; if (i != batchCount) { continue; } --n; _redisConnection.Database.SetAdd(_setKey, identities); _redisConnection.Database.ListRightPush(_queueKey, identities); _redisConnection.Database.HashSet(_itemKey, items); i = 0; if (n != 0) { identities = new RedisValue[batchCount]; items = new HashEntry[batchCount]; } else { identities = new RedisValue[j]; items = new HashEntry[j]; } } if (i <= 0) { return; } _redisConnection.Database.SetAdd(_setKey, identities); _redisConnection.Database.ListRightPush(_queueKey, identities); _redisConnection.Database.HashSet(_itemKey, items); } }); if (UseInternet) { NetworkCenter.Current.Execute("rds-import", action); } else { action(); } }
public void put(int key, int value) { int hash = (key % TABLE_SIZE); while (table[hash] != null && table[hash].key != EntryDeleted && table[hash].key != key) hash = (hash + 1) % TABLE_SIZE; table[hash] = new HashEntry(key, value); }