static void RedisTypedClientInterface()
        {
            long lastId = 0;

            using (var redisClient = new RedisClient())
            {
                IRedisTypedClient <Customer> customerClient = redisClient.As <Customer>();

                var customer = new Customer()
                {
                    Id      = customerClient.GetNextSequence(),
                    Name    = "Customer 1",
                    Address = "#123, St. 123",
                    Orders  = new List <Order> {
                        new Order {
                            OrderNo = "00001"
                        },
                        new Order {
                            OrderNo = "00002"
                        }
                    }
                };

                var storedCustomer = customerClient.Store(customer);
                lastId = storedCustomer.Id;
            }

            using (var redisClient = new RedisClient())
            {
                IRedisTypedClient <Customer> customerClient = redisClient.As <Customer>();
                var customer = customerClient.GetById(lastId);
                Console.WriteLine("Got customer {0}, with name {1}", customer.Id, customer.Name);
            }
        }
 static void Logout(string sessionId)
 {
     using (IRedisClient redisClient = new RedisClient())
     {
         IRedisTypedClient <SessionInfo> sessionClient = redisClient.As <SessionInfo>();
         sessionClient.DeleteById(sessionId);
     }
 }
Example #3
0
        static void Main(string[] args)
        {
            var loggerDebugFactory = new LoggerFactory();

            loggerDebugFactory.AddNLog(new NLogProviderOptions {
                CaptureMessageTemplates = true, CaptureMessageProperties = true
            });
            loggerDebugFactory.ConfigureNLog("nlog.config");
            ILogger <Program> _logger = loggerDebugFactory.CreateLogger <Program>();

            _logger.LogDebug(20, "Doing hard work! {Action}", "abc");
            var a = 10;
            var b = 0;

            try
            {
                a = a / b;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "this is a test");
            }

            var messagesReceived = 0;

            using (var client = new RedisClient("localhost", 6379, "12345^"))
            {
                // redis type string.
                client.Set("student1", new Student
                {
                    Id          = 1,
                    Name        = "Nghiep",
                    CreatedDate = DateTimeOffset.Now
                });
                var student1 = client.Get <Student>("student1");
                // redis type hash.

                client.StoreAsHash <Student>(new Student
                {
                    Id          = 4,
                    Name        = "Nghiep",
                    CreatedDate = DateTimeOffset.Now
                });

                var fromHash = client.GetFromHash <Student>(3);
                if (fromHash.Id != 0)
                {
                    //Exited in cache
                }

                // redis type list.
                var redis      = client.As <Student>();
                var studentKey = string.Format("student:id:{0}", 1);
                var student    = new Student {
                    Id = 1, Name = "Nghiep", CreatedDate = DateTimeOffset.Now
                };

                redis.SetValue(studentKey, student);
                studentKey = string.Format("student:id:{0}", 2);
                student    = new Student {
                    Id = 2, Name = "Nghiep", CreatedDate = DateTimeOffset.Now
                };
                redis.SetValue(studentKey, student);
                var obj = redis.GetValues(new System.Collections.Generic.List <string> {
                    "student:id:1", "student:id:2"
                });



                using (var subscription = client.CreateSubscription())
                {
                    subscription.OnSubscribe = channel =>
                    {
                        _logger.LogDebug(string.Format("Subscribed to '{0}'", channel));
                    };
                    subscription.OnUnSubscribe = channel =>
                    {
                        _logger.LogDebug(string.Format("UnSubscribed from '{0}'", channel));
                    };
                    subscription.OnMessage = (channel, msg) =>
                    {
                        _logger.LogDebug(string.Format("Received '{0}' from channel '{1}'", msg, channel));

                        //As soon as we've received all 5 messages, disconnect by unsubscribing to all channels
                        if (++messagesReceived == PublishMessageCount)
                        {
                            subscription.UnSubscribeFromAllChannels();
                        }
                    };

                    ThreadPool.QueueUserWorkItem(x =>
                    {
                        Thread.Sleep(200);
                        _logger.LogDebug("Begin publishing messages...");

                        using (var redisPublisher = new RedisClient("localhost", 6379, "12345^"))
                        {
                            for (var i = 1; i <= PublishMessageCount; i++)
                            {
                                var message = MessagePrefix + i;
                                _logger.LogDebug(string.Format("Publishing '{0}' to '{1}'", message, ChannelName));
                                redisPublisher.PublishMessage(ChannelName, message);
                                Thread.Sleep(2000);
                            }
                        }
                    });

                    _logger.LogDebug(string.Format("Started Listening On '{0}'", ChannelName));
                    subscription.SubscribeToChannels(ChannelName); //blocking
                }
            }
            Console.ReadLine();
        }
        static void SampleLogin()
        {
            string userName  = "";
            string password  = "";
            string sessionId = "";

            // Define static list of users
            List <User> users = new List <User>()
            {
                new User {
                    UserId = 1, UserName = "******", Password = "******", Email = "*****@*****.**"
                },
                new User {
                    UserId = 2, UserName = "******", Password = "******", Email = "*****@*****.**"
                },
                new User {
                    UserId = 3, UserName = "******", Password = "******", Email = "*****@*****.**"
                },
            };

            // Read username and password from console.
            Console.Write("Enter username: "******"Enter password: "******"Your user {0} have successfully login!", userName);
                }

                // Use logoff
                Console.WriteLine("Press enter to logoff username {0} : ", userName);
                var line = Console.ReadLine();
                if (String.IsNullOrEmpty(line))
                {
                    Logout(sessionId);
                    Environment.Exit(0);
                }
            }
            else
            {
                //User enter incorrect username/password, try login again...
                Console.WriteLine("Login failed! Invalid username/password.");
                SampleLogin();
            }
        }