分布式缓存系统Memcached实践
2016-11-19 本文已影响0人
Bobby0322
Memcached简介
Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。天生支持集群。
目前有多种平台的Memcached版本，比如Linux、FreeBSD、Solaris 、Mac OS X及Windows平台。
官方网站：http://memcached.org/
我们安装Windows版本来演示。
32bit：下载 memcached-win32-1.4.4-14.zip
64bit：如果需要win64版，下载 memcached-win64-1.4.4-14.zip
Memcached 内存管理机制：
Menceched 通过预分配指定的内存空间来存取数据，所有的数据都保存在 memcached 内置的内存中。利用 Slab Allocation 机制来分配和管理内存。按照预先规定的大小，将分配的内存分割成特定长度的内存块，再把尺寸相同的内存块分成组，这些内存块不会释放，可以重复利用。当存入的数据占满内存空间时，Memcached 使用 LRU 算法自动删除不是用的缓存数据，即重用过期数据的内存空间。Memcached 是为缓存系统设计的，因此没有考虑数据的容灾问题，和机器的内存一样，重启机器将会丢失，如果希望服务重启数据依然能保留，那么就需要 sina 网开发的 Memcachedb 持久性内存缓冲系统，当然还有常见的 NOSQL 服务如 redis。默认监听端口：11211
Memcached数据访问模型
-
添加新的键值对数据
从图中可以看出，Memcached虽然称为“分布式”缓存服务器，但服务器端并没有“分布式”功能，而是完全由客户端程序库实现的。服务端之间没有任何联系，数据存取都是通过客户端的算法实现的。当客户端要存取数据时，首先会通过算法查找自己维护的服务器哈希列表，找到对应的服务器后，再将数据存往指定服务器。例如：上图中应用程序要新增一个<'tokyo',data>的键值对，它同过set操作提交给Memcached客户端，客户端通过一定的哈希算法（比如：一般的求余函数或者强大的一致性Hash算法）从服务器列表中计算出一个要存储的服务器地址，最后将该键值对存储到计算出来的服务器里边。 -
获取已存在的键值对数据
上图中应用程序想要获取Key为‘tokyo’的Value，于是它向Memcached客户端提交了一个Get请求，Memcached客户端还是通过算法从服务器列表查询哪台服务器存有Key为‘tokyo’的Value（即选择刚刚Set到了哪台服务器），如果查到，则向查到的服务器请求返回Key为‘tokyo’的数据。
Memcached分布式的核心—一致性Hash算法
一致性Hash算法是分布式缓存的核心理论，我也学习得不深入，也只是刚刚了解了一下，后面我有空深入学习一下。
首先，简单的路由算法（通过使用余数Hash）无法满足业务发展时服务器扩容的需要：缓存命中率下降。例如：当3台服务器扩容至4台时，采用普通的余数Hash算法会导致大约75%（3/4）被缓存了的数据无法正确命中，随着服务器集群规模的增大，这个比例会线性地上升。那么，可以想象，当100台服务器的集群中加入一台服务器，不能命中的概率大概是99%（N/N+1），这个结果显然是无法接受的。那么，能否通过改进路由算法，使得新加入的服务器不影响大部分缓存数据的正确性呢？请看下面的一致性Hash算法。
一致性Hash算法通过一个叫做一致性Hash环的数据结构实现KEY到缓存服务器的Hash映射，如下图所示：
具体算法过程是：
- 先构造一个长度为0~2^32（2的32次幂）个的整数环（又称：一致性Hash环），根据节点名称的Hash值将缓存服务器节点放置在这个Hash环中，如上图中的node1，node2等；
- 根据需要缓存的数据的KEY值计算得到其Hash值，如上图中右半部分的“键”，计算其Hash值后离node2很近；
- 在Hash环上顺时针查找距离这个KEY的Hash值最近的缓存服务器节点，完成KEY到服务器的Hash映射查找，如上图中离右边这个键的Hash值最近的顺时针方向的服务器节点是node2，因此这个KEY会到node2中读取数据；
当缓存服务器集群需要扩容的时候，只需要将新加入的节点名称（如node5）的Hash值放入一致性Hash环中，由于KEY总是顺时针查找距离其最近的节点，因此新加入的节点只影响整个环中的一部分。如下图中所示，添加node5后，只影响右边逆时针方向的三个Key/Value对数据，只占整个Hash环中的一小部分。
因此，我们可以与之前的普通余数Hash作对比：采用一致性Hash算法时，当3台服务器扩容到4台时，可以继续命中原有缓存数据的概率为75%，远高于普通余数Hash的25%，而且随着集群规模越大，继续命中原有缓存数据的概率也会随之增大。当100台服务器增加1台时，继续命中的概率是99%。虽然，仍有小部分数据缓存在服务器中无法被读取到，但是这个比例足够小，通过访问数据库也不会对数据库造成致命的负载压力。
Memcached与Redis的对比
- 没有必要过多的关心性能，因为二者的性能都已经足够高了。由于Redis只使用单核，而Memcached可以使用多核，所以在比较上，平均每一个核上Redis在存储小数据时比Memcached性能更高。而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis最近也在存储大数据的性能上进行优化，但是比起Memcached，还是稍有逊色。说了这么多，结论是，无论你使用哪一个，每秒处理请求的次数都不会成为瓶颈。（比如瓶颈可能会在网卡）
- 如果要说内存使用效率，使用简单的key-value存储的话，Memcached的内存利用率更高，而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。当然，这和你的应用场景和数据特性有关。
- 如果你对数据持久化和数据同步有所要求，那么推荐你选择Redis，因为这两个特性Memcached都不具备。即使你只是希望在升级或者重启系统后缓存数据不会丢失，选择Redis也是明智的。
因此，我们可以得出一个结论：在简单的Key/Value应用场景（例如缓存），Memcached拥有更高的读写性能；而在数据持久化和数据同步场景，Redis拥有更加强大的功能和更为丰富的数据类型；
需要慎重考虑的部分
- Memcached单个key-value大小有限，一个value最大只支持1MB，而Redis最大支持512MB
- Memcached只是个内存缓存，对可靠性无要求；而Redis更倾向于内存数据库，因此对对可靠性方面要求比较高
- 从本质上讲，Memcached只是一个单一key-value内存Cache；而Redis则是一个数据结构内存数据库，支持五种数据类型，因此Redis除单纯缓存作用外，还可以处理一些简单的逻辑运算，Redis不仅可以缓存，而且还可以作为数据库用
- 新版本（3.0）的Redis是指集群分布式，也就是说集群本身均衡客户端请求，各个节点可以交流，可拓展行、可维护性更强大。
- MongoDB不支持事务。
安装和启动
- install
memcached.exe -d install
- start
memcached.exe -d start
- stop
memcached.exe -d stop
- unInstall
memcached.exe -d uninstall
以上的安装和启动都是在默认环境下进行的，在安装时可设置如下参数：
Memcached默认使用端口是11211
默认最大连接数是1024个
默认最大使用内存是64M
默认每个键值对，值存储空间为1M
-p 监听的端口
-l 连接的IP地址, 默认是本机
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-u 以身份运行 (仅在以root运行的时候有效)
-m 最大内存使用，单位MB。默认64MB **
-M 内存耗尽时返回错误，而不是删除项
-c 最大同时连接数，默认是1024 **
-f 块大小增长因子，默认是1.25
-n 最小分配空间，key+value+flags默认是48
-h 显示帮助
OK,命令咱们已经执行完了.怎么才知道Memcached服务已经安装成功并启动了呢?
cmd 命令 services.msc
检测Memcached服务是否成功启动：
使用telnet命令连接到登录台：telnet 服务器IP地址 11211（11211是默认的Memcached服务端口号）
打印当前Memcache服务器状态：stats
stats.png
可以看到，通过stats命令列出了一系列的Memcached服务状态信息，那么这些信息又代表什么意思呢？我们可以通过下图来知道：
先把memcached用起来
下载客户端的4个dll，
ICSharpCode.SharpZipLib.dll，log4net.dll，Memcached.ClientLibrary.dll，Commons.dll
跟着我新建一个简单控制台应用程序
using Memcached.ClientLibrary;
using System;
namespace Tdf.RedisCacheTest
{
class AMemcached
{
public static MemcachedClient cache;
static AMemcached()
{
string[] servers = { "127.0.0.1:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1 });
// 初始化时创建连接数
pool.InitConnections = 3;
// 最小连接数
pool.MinConnections = 3;
// 最大连接数
pool.MaxConnections = 5;
// 连接的最大空闲时间，下面设置为6个小时（单位ms），超过这个设置时间，连接会被释放掉
pool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间，下面设置表示不超时（单位ms），即一直保持链接状态
pool.SocketConnectTimeout = 0;
// 通讯的超时时间，下面设置为3秒（单位ms），.Net版本没有实现
pool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间，下面设置为30秒（单位s），设置为0时表示不启用维护线程
pool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
pool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法，.net版本没有实现
pool.Nagle = false;
// socket单次任务的最大时间（单位ms），超过这个时间socket会被强行中端掉，当前任务失败。
pool.MaxBusy = 1000 * 10;
pool.Initialize();
cache = new MemcachedClient();
// 是否启用压缩数据：如果启用了压缩，数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置，超过指定大小的都压缩
cache.CompressionThreshold = 1024 * 1024;
}
}
class Program
{
static void Main(string[] args)
{
// 存入key为userName，value为Bobby的一个缓存
AMemcached.cache.Add("userName", "Bobby");
// 读出key为a的缓存值
var s = AMemcached.cache.Get("userName");
// 输出
Console.WriteLine(s);
Console.Read();
}
}
}
细品 .NET Memcached.ClientLibrary
说说memcached分布式缓存的设置与应用
string[] servers = { "127.0.0.1:11211", "192.168.2.100:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1, 10 });
Note：
- 在172.18.5.66，与192.168.10.121两台机器上装memcached服务端。
- pool.SetWeights这里的1跟10意思是，负载均衡比例，假如11000条数据，大致数据分布为：172.18.5.66分布1000条数据左右。另外一台为10000条左右。
- memcached服务端并不具备负载均衡的能力，而是memcachedClient实现的，具体存取数据实现的核心是采用一致性Hash算法，把key-value分布到某一台服务器中里边。
说说memcached的数据压缩机制
// 是否启用压缩数据：如果启用了压缩，数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置，超过指定大小的都压缩
cache.CompressionThreshold = 1024 * 1024;
Note：
- 这个处理是在MemcachedClient对象中，设置这个EnableCompression属性，是否使用压缩的意思，如果启用啦压缩功能 ,则ICSharpCode.SharpZipLib类库会在数据超过预设大小时，进行数据压缩处理。
- CompressionThreshold这个属性是压缩的阀值，默认是15K，如果超过设定的阀值则使用memcached的通讯协议，存数据时给每个数据项分配一个16为的flag表示，用作记录是否有压缩，如果有压缩则提取数据是进行解压。如果没有超过阀值则不压缩，直接存储。
说说怎么使用客户端多个SocketIO池
using Memcached.ClientLibrary;
using System;
namespace Tdf.RedisCacheTest
{
class AMemcached
{
public MemcachedClient cache;
public AMemcached(string poolName)
{
string[] servers = { "127.0.0.1:11211", "192.168.2.100:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1, 10 });
// 初始化时创建连接数
pool.InitConnections = 3;
// 最小连接数
pool.MinConnections = 3;
// 最大连接数
pool.MaxConnections = 5;
// 连接的最大空闲时间，下面设置为6个小时（单位ms），超过这个设置时间，连接会被释放掉
pool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间，下面设置表示不超时（单位ms），即一直保持链接状态
pool.SocketConnectTimeout = 0;
// 通讯的超时时间，下面设置为3秒（单位ms），.Net版本没有实现
pool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间，下面设置为30秒（单位s），设置为0时表示不启用维护线程
pool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
pool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法，.net版本没有实现
pool.Nagle = false;
// socket单次任务的最大时间（单位ms），超过这个时间socket会被强行中端掉，当前任务失败。
pool.MaxBusy = 1000 * 10;
pool.Initialize();
cache = new MemcachedClient();
// 是否启用压缩数据：如果启用了压缩，数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置，超过指定大小的都压缩
cache.CompressionThreshold = 1024 * 1024;
}
}
class Program
{
static void Main(string[] args)
{
// 存入key为userName，value为Bobby的一个缓存
new AMemcached("poolName").cache.Add("b", 123);
// AMemcached.cache.Add("userName", "Bobby");
// 读出key为a的缓存值
var s = new AMemcached("poolName").cache.Get("userName");
// 输出
Console.WriteLine(s);
Console.Read();
}
}
}
说说memcached的故障转移处理
// 设置SocktIO池的故障标志
pool.Failover = true;
Note：memcached的鼓掌转移是一套正常节点发生故障变为死节点时的处理机制。
- 开启故障转移：如果发生socket异常，则该节点被添加到存放死节点属性的_hostDead中，新请求被映射到dead server，检测尝试连接死节点的时间间隔属性_hostDeadDuration（默认设置为100ms），如果没有达到设定的间隔时间则key会被映射到可用的server处理，如果达到了时间间隔，则尝试重新链接，连接成功将此节点从_hostDead中去除，连接失败则间隔时间翻倍存放，下次重新连接时间会被拉长。
- 不开启故障转移：新的请求都会被映射到dead server上，尝试重新建立socket链接，如果连接失败，返回null或者操作失败。
说说key-value中的key与value
- key在服务端的长度限制为250个字符，建议使用较短的key但不要重复。
- value的大小限制为1mb，如果大拉，可以使用压缩，如果还大，那可能拆分到多个key中。
Memcached 客户端使用封装
抽象出来了一个接口：
using System;
namespace Tdf.Memcached
{
public interface IMemcached
{
void Add(string key, object value);
void Add(string key, object value, DateTime expiredDateTime);
void Update(string key, object value);
void Update(string key, object value, DateTime expiredDateTime);
void Set(string key, object value);
void Set(string key, object value, DateTime expiredTime);
void Delete(string key);
object Get(string key);
bool KeyExists(string key);
}
}
MemcacheHelper.cs
using Memcached.ClientLibrary;
using System;
using System.Configuration;
namespace Tdf.Memcached
{
/// <summary>
/// 基于Memcached.ClientLibrary封装使用Memchached信息
/// 读取缓存存放在服务器
/// </summary>
public class MemcacheHelper
{
/// <summary>
/// 字段_instance,存放注册的缓存信息
/// </summary>
private static MemcacheHelper _instance;
/// <summary>
/// 缓存客户端
/// </summary>
private readonly MemcachedClient _client;
/// <summary>
/// 受保护类型的缓存对象，初始化一个新的缓存对象
/// </summary>
protected MemcacheHelper()
{
// 读取app.Config中需要缓存的服务器地址信息，可以传递多个地址，使用";"分隔
string[] serverList = ConfigurationManager.AppSettings["readWriteHosts"].Split(new char[] { ';' });
try
{
// 初始化池
var sockIoPool = SockIOPool.GetInstance();
// 设置服务器列表
sockIoPool.SetServers(serverList);
// 各服务器之间负载均衡的设置比例
sockIoPool.SetWeights(new int[] { 1 });
// 初始化时创建连接数
sockIoPool.InitConnections = 3;
// 最小连接数
sockIoPool.MinConnections = 3;
// 最大连接数
sockIoPool.MaxConnections = 5;
// 连接的最大空闲时间，下面设置为6个小时（单位ms），超过这个设置时间，连接会被释放掉
sockIoPool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间，下面设置表示不超时（单位ms），即一直保持链接状态
sockIoPool.SocketConnectTimeout = 0;
// 通讯的超时时间，下面设置为3秒（单位ms）,.Net版本没有实现
sockIoPool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间，下面设置为30秒（单位s），设置为0时表示不启用维护线程
sockIoPool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
sockIoPool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法，.net版本没有实现
sockIoPool.Nagle = false;
// socket单次任务的最大时间（单位ms），超过这个时间socket会被强行中端掉，当前任务失败。
sockIoPool.MaxBusy = 1000 * 10;
sockIoPool.Initialize();
// 实例化缓存对象
_client = new MemcachedClient();
// 是否启用压缩数据：如果启用了压缩，数据压缩长于门槛的数据将被储存在压缩的形式
_client.EnableCompression = false;
// 压缩设置，超过指定大小的都压缩
_client.CompressionThreshold = 1024 * 1024;
}
catch (Exception ex)
{
// 错误信息写入事务日志
throw new Exception(ex.Message);
}
}
/// <summary>
/// 获取缓存的实例对象，方法调用的时候使用
/// </summary>
/// <returns></returns>
public static MemcacheHelper GetInstance()
{
return _instance;
}
/// <summary>
/// 添加缓存信息(如果存在缓存信息则直接重写设置，否则添加)
/// 使用：MemcacheHelper.GetInstance().Add(key,value)
/// </summary>
/// <param name="key">需要缓存的键</param>
/// <param name="value">需要缓存的值</param>
public void Add(string key, object value)
{
if (_client.KeyExists(key))
{
_client.Set(key, value);
}
_client.Add(key, value);
}
/// <summary>
/// 添加缓存信息
/// 使用：MemcacheHelper.GetInstance().Add(key,value,Datetime.Now())
/// </summary>
/// <param name="key">需要缓存的键</param>
/// <param name="value">需要缓存的值</param>
/// <param name="expiredDateTime">设置的缓存的过时时间</param>
public void Add(string key, object value, DateTime expiredDateTime)
{
_client.Add(key, value, expiredDateTime);
}
/// <summary>
/// 修改缓存的值
/// 使用：MemcacheHelper.GetInstance().Update(key,value)
/// </summary>
/// <param name="key">需要修改的键</param>
/// <param name="value">需要修改的值</param>
public void Update(string key, object value)
{
_client.Replace(key, value);
}
/// <summary>
/// 修改缓存的值
/// 使用：MemcacheHelper.GetInstance().Update(key,value,Datetime.Now())
/// </summary>
/// <param name="key">需要修改的键</param>
/// <param name="value">需要修改的值</param>
/// <param name="expiredDateTime">设置的缓存的过时时间</param>
public void Update(string key, object value, DateTime expiredDateTime)
{
_client.Replace(key, value, expiredDateTime);
}
/// <summary>
/// 设置缓存
/// 使用：MemcacheHelper.GetInstance().Set(key,value)
/// </summary>
/// <param name="key">设置缓存的键</param>
/// <param name="value">设置缓存的值</param>
public void Set(string key, object value)
{
_client.Set(key, value);
}
/// <summary>
/// 设置缓存，并修改过期时间
/// 使用：MemcacheHelper.GetInstance().Set(key,value,Datetime.Now())
/// </summary>
/// <param name="key">设置缓存的键</param>
/// <param name="value">设置缓存的值</param>
/// <param name="expiredTime">设置缓存过期的时间</param>
public void Set(string key, object value, DateTime expiredTime)
{
_client.Set(key, value, expiredTime);
}
/// <summary>
/// 删除缓存
/// 使用：MemcacheHelper.GetInstance().Delete(key)
/// </summary>
/// <param name="key">需要删除的缓存的键</param>
public void Delete(string key)
{
_client.Delete(key);
}
/// <summary>
/// 获取缓存的值
/// 使用：MemcacheHelper.GetInstance().Get(key)
/// </summary>
/// <param name="key">传递缓存中的键</param>
/// <returns>返回缓存在缓存中的信息</returns>
public object Get(string key)
{
return _client.Get(key);
}
/// <summary>
/// 缓存是否存在
/// 使用：MemcacheHelper.GetInstance().KeyExists(key)
/// </summary>
/// <param name="key">传递缓存中的键</param>
/// <returns>如果为true，则表示存在此缓存，否则比表示不存在</returns>
public bool KeyExists(string key)
{
return _client.KeyExists(key);
}
/// <summary>
/// 注册Memcache缓存(在Global.asax的Application_Start方法中注册)
/// 使用：MemcacheHelper.RegisterMemcache();
/// </summary>
public static void RegisterMemcache()
{
if (_instance == null)
{
_instance = new MemcacheHelper();
}
}
}
}
App.config
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
</startup>
<appSettings>
<add key="readWriteHosts" value="127.0.0.1:11211" />
</appSettings>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="ICSharpCode.SharpZipLib" publicKeyToken="1b03e6acf1164f73" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-0.84.0.0" newVersion="0.84.0.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>
Program.cs
using System;
using Tdf.Memcached;
namespace Tdf.MemcachedTest
{
class Program
{
static void Main(string[] args)
{
// 注册Memcache缓存
MemcacheHelper.RegisterMemcache();
// 添加缓存信息(如果存在缓存信息则直接重写设置，否则添加)
MemcacheHelper.GetInstance().Add("userName", "Bobby");
// 缓存是否存在
var tf = MemcacheHelper.GetInstance().KeyExists("userName");
Console.WriteLine(tf);
// 获取缓存的值
var s = MemcacheHelper.GetInstance().Get("userName");
Console.WriteLine(s);
Console.Read();
}
}
}
到此，我们已经完成了一个最小化的memcached集群读写测试Demo。但是，在实际的开发场景中，远不仅仅是存储一个字符串，更多的是存储一个自定义的类的实例对象。这就需要使用到序列化，下面我们来新加一个类Claim，让其作为可序列化的对象来存储进Memcached中。注意：需要为该类加上[Serializable]的特性！
using System;
using Tdf.Memcached;
namespace Tdf.MemcachedTest
{
[Serializable]
public class Claim
{
public int UserId { get; set; }
public string UserName { get; set; }
}
class Program
{
static void Main(string[] args)
{
// 注册Memcache缓存
MemcacheHelper.RegisterMemcache();
// 自定义对象存储
Claim claim = new Claim();
claim.UserId = 694802856;
claim.UserName = "难念的经";
MemcacheHelper.GetInstance().Add("Claim", claim);
Claim newMyObj = MemcacheHelper.GetInstance().Get("Claim") as Claim;
Console.WriteLine("Hello,My UserId is {0} and UserName is {1}", newMyObj.UserId, newMyObj.UserName);
Console.Read();
}
}
}
