private static void UsingIRedisTypedClient(RedisClient client)
{
var redisTodos = client.As<Todo>();
//Mark all Todos, that have passed deadline, as DONE
redisTodos.GetAll()
.Where(t => t.Deadline >= DateTime.Now)
//Extension method to execute a lambda expression for each element of a IEnumerable<T>
.ForEach(t => t.IsDone = true);
var todo = new Todo()
{
Id = redisTodos.GetNextSequence(),
Text = "Todo created at " + DateTime.Now,
Deadline = DateTime.Now.AddDays(1),
IsDone = false,
AssignedTo = new User()
{
Name = "Doncho"
}
};
redisTodos.Store(todo);
redisTodos.GetAll()
.Print();
}
private void btnBorrar_Click(object sender, EventArgs e)
{
try
{
if (MetroFramework.MetroMessageBox.Show(this, "Estas seguro de que vas a borrar el " +
"registro!", "Mensaje", MessageBoxButtons.YesNo, MessageBoxIcon.Question) ==
DialogResult.Yes)
{
Empleado em = empleadoBindingSource.Current as Empleado;
if (em != null)
{
using (RedisClient cliente = new RedisClient("192.168.99.100", 6379))
{
IRedisTypedClient <Empleado> empleado = cliente.As <Empleado>();
empleado.DeleteById(em.ID);
empleadoBindingSource.RemoveCurrent();
Limpiar();
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Set <T>(string key, T value, TimeSpan timeout)
{
using (RedisClient client = new RedisClient(_endPoint))
{
client.As <T>().SetValue(key, value, timeout);
}
}
static void Main(string[] args)
{
var lastId = 0L;
using (IRedisClient client = new RedisClient("redis://192.241.154.174:6379"))
{
var customerClient = client.As <Customer>();
var customer = new Customer
{
Id = customerClient.GetNextSequence(),
Address = "123 Main Street",
Name = "Bob Green",
Orders = new List <Order>
{
new Order {
OrderNumber = "AB123"
},
new Order {
OrderNumber = "AB124"
}
}
};
var storedCustomer = customerClient.Store(customer);
lastId = storedCustomer.Id;
}
using (IRedisClient client = new RedisClient("redis://192.241.154.174:6379"))
{
var customerClient = client.As <Customer>();
var customer = customerClient.GetById(lastId);
Console.WriteLine($"Got Customer {customer.Id}, with name: {customer.Name}");
}
}
public virtual void OnBeforeEachTest()
{
if (Redis != null) Redis.Dispose();
Redis = new RedisClient(TestConfig.SingleHost);
Redis.NamespacePrefix = "RedisTypedClientTests:";
RedisTyped = Redis.As<CacheRecord>();
}
public virtual void OnBeforeEachTest()
{
if (Redis != null) Redis.Dispose();
Redis = new RedisClient(TestConfig.SingleHost);
Redis.FlushDb();
RedisTyped = Redis.As<CacheRecord>();
}
public void Working_with_int_values()
{
const string intKey = "intkey";
const int intValue = 1;
//STORING AN INT USING THE BASIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
redisClient.SetValue(intKey, intValue.ToString());
string strGetIntValue = redisClient.GetValue(intKey);
int toIntValue = int.Parse(strGetIntValue);
Assert.That(toIntValue, Is.EqualTo(intValue));
}
//STORING AN INT USING THE GENERIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
//Create a generic client that treats all values as ints:
IRedisTypedClient <int> intRedis = redisClient.As <int>();
intRedis.SetValue(intKey, intValue);
var toIntValue = intRedis.GetValue(intKey);
Assert.That(toIntValue, Is.EqualTo(intValue));
}
}
public void storeInCache(Hashtable table, int id)
{
//IDatabase db = redis.GetDatabase();
using (RedisClient redisClient = new RedisClient(host))
{
IRedisTypedClient <CpuUsage> processes = redisClient.As <CpuUsage>();
CpuUsage process = new CpuUsage
{
id = id,
process = new ProcessArrayList
{
process = table
}
};
processes.SetEntry(id.ToString(), process);
redisClient.Expire(id.ToString(), 120);
}
//CpuUsage process = new CpuUsage
//{
// id = id,
// process = new ProcessArrayList
// {
// process = table
// }
//};
////Store the processes and set expiry time
//string value = JsonConvert.SerializeObject(process);
//db.StringSet(id.ToString(), value);
//db.KeyExpire(id.ToString(), DateTime.Now.AddMinutes(2));
}
private void saveScreen()
{
Rectangle bounds = Screen.GetBounds(Point.Empty);
using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
{
using (Graphics g = Graphics.FromImage(bitmap))
{
g.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
}
//var fileLocation = string.Format(@"D:\tmp\src\screen_{0}.jpg", DateTime.Now.ToString("yyyyMMddHHssfff"));
//bitmap.Save(fileLocation, ImageFormat.Jpeg);
//File.WriteAllText(fileLocation.Replace(".jpg", ".txt"), Constant.PointToString(Constant.GetCursorPosition()));
using (IRedisClient client = new RedisClient())
{
//IRedisTypedClient
var customerClient = client.As <Customer>();
var customer = new Customer()
{
Id = Constant.lastCustomerId,
Data = getBase64(bitmap),
Point = Constant.PointToString(Constant.GetCursorPosition())
};
var savedCustomer = customerClient.Store(customer);
Debug.WriteLine("Mesaj id : {0}", Constant.lastCustomerId);
}
}
}
public void SaveItem(Item item)
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
var itemClient = client.As <Item>();
var itemList = itemClient.Lists["urn:item:" + item.ProductID];
item.Id = itemClient.GetNextSequence();
itemList.Add(item);
client.AddItemToSortedSet("urn:Rank", item.Name, item.Price);
//Publis top 5 Ranked Items
IDictionary <string, double> Data = client.GetRangeWithScoresFromSortedSet("urn:Rank", 0, 4);
List <Item> RankList = new List <Item>();
int counter = 0;
foreach (var itm in Data)
{
counter++;
RankList.Add(new Item()
{
Name = itm.Key, Price = (int)itm.Value, Id = counter
});
}
var itemJson = JsonConvert.SerializeObject(RankList);
client.PublishMessage("Rank", itemJson);
//---------------------------------------------
}
}
public ActionResult Save(string userName, int goal, long?userId)
{
using (IRedisClient client = new RedisClient())
{
var userClient = client.As <User>();
User user;
if (userId != null)
{
user = userClient.GetById(userId);
client.RemoveItemFromSortedSet("urn:leaderboard", user.Name);
}
else
{
user = new User
{
Id = userClient.GetNextSequence()
};
}
user.Name = userName;
user.Goal = goal;
userClient.Store(user);
userId = user.Id; //In case we are creating a new user
client.AddItemToSortedSet("urn:leaderboard", user.Name, user.Total);
}
return(RedirectToAction("Index", "Tracker", new { userId }));
}
public void Working_with_int_values()
{
const string intKey = "intkey";
const int intValue = 1;
//STORING AN INT USING THE BASIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
redisClient.SetEntry(intKey, intValue.ToString());
string strGetIntValue = redisClient.GetValue(intKey);
int toIntValue = int.Parse(strGetIntValue);
Assert.That(toIntValue, Is.EqualTo(intValue));
}
//STORING AN INT USING THE GENERIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
//Create a generic client that treats all values as ints:
IRedisTypedClient<int> intRedis = redisClient.As<int>();
intRedis.SetEntry(intKey, intValue);
var toIntValue = intRedis.GetValue(intKey);
Assert.That(toIntValue, Is.EqualTo(intValue));
}
}
public ActionResult Save(string userName, int goal, long?userId)
{
using (IRedisClient client = new RedisClient(new RedisEndpoint {
Host = "117.20.40.28", Port = 6379, Password = "******"
}))
{
var userClient = client.As <User>();
User user;
if (userId != null)
{
user = userClient.GetById(userId);
client.RemoveItemFromSortedSet("urn:leaderboard", user.Name);
}
else
{
user = new User
{
Id = userClient.GetNextSequence()
};
}
user.Name = userName;
user.Goal = goal;
userClient.Store(user);
userId = user.Id;
client.AddItemToSortedSet("urn:leaderboard", user.Name, user.Total);
}
return(RedirectToAction("Index", "Tracker", new { userId }));
}
public void Can_Retrieve_DomainEvents()
{
var userId = Guid.NewGuid();
var client = new RedisClient(TestConfig.SingleHost);
client.FlushAll();
client.As<DomainEvent>().Lists["urn:domainevents-" + userId].Add(new UserPromotedEvent { UserId = userId });
var users = client.As<DomainEvent>().Lists["urn:domainevents-" + userId];
Assert.That(users.Count, Is.EqualTo(1));
var userPromoEvent = (UserPromotedEvent)users[0];
Assert.That(userPromoEvent.UserId, Is.EqualTo(userId));
}
//[HttpPost]
public ActionResult CreateFromId(string isbn)
{
string fullUri = getBookInfoUri + isbn;
HttpWebRequest webRequest = GetWebRequest(fullUri);
HttpWebResponse response = (HttpWebResponse)webRequest.GetResponse();
string jsonResponse = string.Empty;
using (StreamReader sr = new StreamReader(response.GetResponseStream()))
{
jsonResponse = sr.ReadToEnd();
}
JObject o = JObject.Parse(jsonResponse);
Book newBook = new Book();
newBook.Id = long.Parse(isbn);
newBook.BookName = (string)o["data"][0]["title"];
newBook.Author = (string)o["data"][0]["author_data"][0]["name"];
newBook.Edition = (string)o["data"][0]["edition_info"];
newBook.Publisher = (string)o["data"][0]["publisher_text"];
newBook.Summary = (string)o["data"][0]["summary"];
using (var redisClient = new RedisClient())
{
var redisUsers = redisClient.As <Book>();
ViewBag.pageOfBooks = redisUsers.GetAll();
return(View());
}
return(View("Index"));
}
public FullEmployee Map(Employee source)
{
FullEmployee employee = new FullEmployee()
{
Id = source.Id,
Age = source.Age,
BirthDate = source.BirthDate,
Name = source.Name
};
var mapper = new FullRoleMapper();
var client = new RedisClient("localhost");
employee.Roles = _roles.Where(r => source.Roles.Contains(r.Id)).ToList();
if (employee.Roles.Count != source.Roles.Count)
{
var newRoles = client
.As<Role>()
.GetByIds(source.Roles.Except(employee.Roles.Select(r => r.Id)))
.Select(r => mapper.Map(r)))
.ToList();
employee.Roles.AddRange(newRoles);
_roles.AddRange(newRoles);
}
return employee;
}
public List <TickDTO> GetTickRaw(int securityId, int count = 200)
{
List <Tick> ticks;
using (var redisTypedClient = RedisClient.As <Tick>())
{
var list = redisTypedClient.Lists[Ticks.GetTickListNamePrefix(TickSize.Raw) + securityId];
//ticks = list.GetAll();
var listSize = list.Count;
ticks = list.GetRange(listSize - count, listSize);
}
List <TickDTO> result;
if (ticks.Count == 0)
{
result = new List <TickDTO>();
}
else
{
//var lastTickTime = ticks.Last().T;
//result = ticks.Where(o => lastTickTime - o.T <= TimeSpan.FromMinutes(30)).Select(o => Mapper.Map<TickDTO>(o)).ToList();
result = ticks.Select(o => Mapper.Map <TickDTO>(o)).ToList();
}
return(result);
}
public override bool ValidateUser(string username, string password)
{
using (RedisClient rClient = new RedisClient(DatabaseConfig.Host, DatabaseConfig.Port, db: DatabaseConfig.Database))
{
var client = rClient.As <RedisMember>();
var rm = client.GetAll().SingleOrDefault(m => m.UserName.ToLower() == username.ToLower());
if (rm == null || !(rm.IsApproved && !rm.IsLockedOut))
{
return(false);
}
byte[] salt = rm.PassSalt;
byte[] hash = calculateHash(password, ref salt);
bool isFail = false;
for (int i = 0; i > hash.Length; i++)
{
isFail |= (hash[i] != rm.PassHash[i]);
}
if (isFail)
{
if (rm.LockoutWindowStart == DateTime.MinValue)
{
rm.LockoutWindowStart = DateTime.Now;
rm.LockoutWindowAttempts = 1;
}
else
{
if (rm.LockoutWindowStart.AddMinutes(PasswordAttemptWindow) > DateTime.Now)
{
// still within window
rm.LockoutWindowAttempts++;
if (rm.LockoutWindowAttempts >= MaxInvalidPasswordAttempts)
{
rm.IsLockedOut = true;
}
}
else
{
// outside of window, reset
rm.LockoutWindowStart = DateTime.Now;
rm.LockoutWindowAttempts = 1;
}
}
}
else
{
rm.LastLoginDate = DateTime.Now;
rm.LockoutWindowStart = DateTime.MinValue;
rm.LockoutWindowAttempts = 0;
}
client.Store(rm);
return(!isFail);
}
}
/// <summary>
/// To validates the user with username and password
/// </summary>
/// <param name="userName">user's username</param>
/// <param name="userId">user's password</param>
/// <returns>User object for the requested userId</returns>
public User ValidateUser(string userName, string password)
{
using (var redisClient = new RedisClient(AppSettings.RedisServer))
{
return(redisClient.As <User>().GetAll().ToList().
Where(x => x.UserName == userName && x.Password == password).SingleOrDefault());
}
}
/// <summary>
/// To check is user already exists
/// </summary>
/// <param name="userName">user's username</param>
/// <returns>user existance (either yes or no)</returns>
public bool IsUserExists(string userName)
{
using (var redisClient = new RedisClient(AppSettings.RedisServer))
{
return(redisClient.As <User>().GetAll().ToList().
Any <User>(x => x.UserName == userName));
}
}
public void DeletePlayer(int id)
{
using (IRedisClient client = new RedisClient(host, port, pw))
{
var playerClient = client.As <Player>();
playerClient.DeleteById(id);
}
}
public UserManipulate()
{
if (!CheckNextGlobalCounterUserIdExist())
{
var redisCounterSetup = redis.As <string>();
redisCounterSetup.SetEntry(globalCounterUserId, "0");
}//provera da li vec postoji brojac za user-a (ako ne postoji postavlja se novi na 0)
}
private void Form1_Load(object sender, EventArgs e)
{
using (RedisClient client = new RedisClient("localhost", 6379)) {
IRedisTypedClient <Phone> phone = client.As <Phone>();
phoneBindingSource.DataSource = phone.GetAll();
Edit(true);//Read only
}
}
public void DeleteAllPlayers()
{
using (IRedisClient client = new RedisClient(host, port, pw))
{
var playerClient = client.As <Player>();
playerClient.DeleteAll();
}
}
/// <summary>
/// store 泛型值
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static void StroteEntity <T>(T value)
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
entity.Store(value);
}
}
public static ServerMappingEntry GetEntryById(long id)
{
using (var RedisConnection = new RedisClient(EnvVar.AsString("Redis_Hostname"), EnvVar.AsInt("Redis_Port")))
{
var ListServerMappingEntry = RedisConnection.As <ServerMappingEntry>();
return(ListServerMappingEntry.GetById(id));
}
}
/// <summary>
/// 获得泛型类型T的所有值
/// </summary>
/// <returns></returns>
public static List <T> GetEntitys <T>()
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
return(entity.GetAll().ToList());
}
}
/// <summary>
/// 搜索实体
/// </summary>
/// <param name=""></param>
/// <param name="DoSearch"></param>
/// <returns></returns>
public static IEnumerable <T> SearchEntitys <T>(Func <T, bool> DoSearch)
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
return(entity.GetAll().Where(DoSearch));
}
}
public static IList <ServerMappingEntry> GetAll()
{
using (var RedisConnection = new RedisClient(EnvVar.AsString("Redis_Hostname"), EnvVar.AsInt("Redis_Port")))
{
var ListServerMappingEntry = RedisConnection.As <ServerMappingEntry>();
return(ListServerMappingEntry.GetAll());
}
}
/// <summary>
/// store泛型类型列表
/// </summary>
/// <param name="vals"></param>
/// <returns></returns>
public static void StoreEntity <T>(List <T> vals)
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
entity.StoreAll(vals);
}
}
/// <summary>
/// 获得泛型类型的下一个序列
/// </summary>
/// <returns></returns>
public static long GetNextSequence <T>()
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
return(entity.GetNextSequence());
}
}
public static IEnumerable <MetaItem> Select()
{
using (RedisClient rClient = new RedisClient("localhost", 6379, db: 1))
{
var client = rClient.As <MetaItem>();
return(client.GetAll());
}
}
public void DeleteByKey(long key)
{
using (IRedisClient client = new RedisClient())
{
var genericClient = client.As <T>();
genericClient.DeleteById(key);
}
}
/// <summary>
/// 通过Id搜索
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static T SearchEneitys <T>(long id)
{
using (var client = new RedisClient(Host))
{
var entity = client.As <T>();
return(entity.GetById(id));
}
}
public void Throws_on_access_of_21_types()
{
using (var client = new RedisClient(TestConfig.SingleHost))
{
Access20Types();
Access20Types();
Assert.Throws<LicenseException>(() =>
client.As<T21>());
}
}
public void Allows_access_of_more_than_21_types()
{
using (var client = new RedisClient(TestConfig.SingleHost))
{
Access20Types();
Access20Types();
client.As<T21>();
Assert.Pass();
client.As<T22>();
Assert.Pass();
client.As<T23>();
Assert.Pass();
client.As<T24>();
Assert.Pass();
}
}
public TransportMessage Receive()
{
using (var redisClient = new RedisClient())
{
var redis = redisClient.As<TransportMessage>();
var message = redis.GetValue(string.Format("{0}:{1}", _address.Machine, _address.Queue));
return message;
}
}
public void Allows_access_of_21_types()
{
Licensing.RegisterLicense(new AppSettings().GetString("servicestack:license"));
using (var client = new RedisClient(TestConfig.SingleHost))
{
Access20Types();
Access20Types();
client.As<T21>();
}
}
public void SetUp()
{
if (client != null)
{
client.Dispose();
client = null;
}
client = new RedisClient(TestConfig.SingleHost);
client.FlushAll();
redis = client.As<CustomType>();
List = redis.Lists[ListId];
List2 = redis.Lists[ListId2];
}
public void Can_from_Retrieve_DomainEvents_list()
{
var client = new RedisClient(TestConfig.SingleHost);
var users = client.As<AggregateEvents>();
var userId = Guid.NewGuid();
var eventsForUser = new AggregateEvents
{
Id = userId,
Events = new List<DomainEvent>()
};
eventsForUser.Events.Add(new UserPromotedEvent { UserId = userId });
users.Store(eventsForUser);
var all = users.GetAll();
}
public void Working_with_int_list_values()
{
const string intListKey = "intListKey";
var intValues = new List<int> { 2, 4, 6, 8 };
//STORING INTS INTO A LIST USING THE BASIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
IList<string> strList = redisClient.Lists[intListKey];
//storing all int values in the redis list 'intListKey' as strings
intValues.ForEach(x => strList.Add(x.ToString()));
//retrieve all values again as strings
List<string> strListValues = strList.ToList();
//convert back to list of ints
List<int> toIntValues = strListValues.ConvertAll(x => int.Parse(x));
Assert.That(toIntValues, Is.EqualTo(intValues));
//delete all items in the list
strList.Clear();
}
//STORING INTS INTO A LIST USING THE GENERIC CLIENT
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
//Create a generic client that treats all values as ints:
IRedisTypedClient<int> intRedis = redisClient.As<int>();
IRedisList<int> intList = intRedis.Lists[intListKey];
//storing all int values in the redis list 'intListKey' as ints
intValues.ForEach(x => intList.Add(x));
List<int> toIntListValues = intList.ToList();
Assert.That(toIntListValues, Is.EqualTo(intValues));
}
}
protected void Access20Types()
{
using (var client = new RedisClient(TestConfig.SingleHost))
{
client.As<T01>();
client.As<T02>();
client.As<T03>();
client.As<T04>();
client.As<T05>();
client.As<T06>();
client.As<T07>();
client.As<T08>();
client.As<T09>();
client.As<T10>();
client.As<T11>();
client.As<T12>();
client.As<T13>();
client.As<T14>();
client.As<T15>();
client.As<T16>();
client.As<T17>();
client.As<T18>();
client.As<T19>();
client.As<T20>();
}
}
public void Working_with_Generic_types()
{
using (var redisClient = new RedisClient(TestConfig.SingleHost))
{
//Create a typed Redis client that treats all values as IntAndString:
var typedRedis = redisClient.As<IntAndString>();
var pocoValue = new IntAndString { Id = 1, Letter = "A" };
typedRedis.SetEntry("pocoKey", pocoValue);
IntAndString toPocoValue = typedRedis.GetValue("pocoKey");
Assert.That(toPocoValue.Id, Is.EqualTo(pocoValue.Id));
Assert.That(toPocoValue.Letter, Is.EqualTo(pocoValue.Letter));
var pocoListValues = new List<IntAndString> {
new IntAndString {Id = 2, Letter = "B"},
new IntAndString {Id = 3, Letter = "C"},
new IntAndString {Id = 4, Letter = "D"},
new IntAndString {Id = 5, Letter = "E"},
};
IRedisList<IntAndString> pocoList = typedRedis.Lists["pocoListKey"];
//Adding all IntAndString objects into the redis list 'pocoListKey'
pocoListValues.ForEach(x => pocoList.Add(x));
List<IntAndString> toPocoListValues = pocoList.ToList();
for (var i = 0; i < pocoListValues.Count; i++)
{
pocoValue = pocoListValues[i];
toPocoValue = toPocoListValues[i];
Assert.That(toPocoValue.Id, Is.EqualTo(pocoValue.Id));
Assert.That(toPocoValue.Letter, Is.EqualTo(pocoValue.Letter));
}
}
}
public void Allows_access_of_21_types()
{
#if NETCORE
Environment.GetEnvironmentVariable("SERVICESTACK_LICENSE");
#else
Licensing.RegisterLicense(new AppSettings().GetString("servicestack:license"));
#endif
using (var client = new RedisClient(TestConfig.SingleHost))
{
Access20Types();
Access20Types();
client.As<T21>();
}
}