C#语法——泛型的多种应用
本篇文章主要介绍泛型的应用。
泛型是.NET Framework 2.0 版类库就已经提供的语法，主要用于提高代码的可重用性、类型安全性和效率。
泛型的定义
下面定义了一个普通类和一个泛型类，我们可以明确看到泛型类和普通类最大的区别就是多了一个<T>。
所以，这个<T>就标记了，这个类是泛型类。其中这个T，也可以写成A,B,C,D或其他字符。
|
1
2
3
4
|
public
class
Generic
{
public
String Name;
}
|
|
1
2
3
4
|
public
class
Generic<T>
{
public
T Name;
}
|
泛型，顾名思义，就是泛指的类型。好比男人，女人，白人，黑人，可以泛称为【人】。
但类型只能是一个类型。 那么泛型和类型之间是什么关系呢？
其实很简单，泛型在定义的时候，是泛指类型；在使用的时候，就需要被指定，到底使用哪个类型。
即，使用时，就不在是泛指类型，而是特定类型。
好比，定义时，定义了一个人。但在使用时，必须明确指定，到底是黑人还是白人。
泛型的使用
泛型类跟普通类的使用方式一样，都需要实例化对象，再由对象来调用内部的属性或方法。
下面代码实例化了泛型Generic，实例化时，还指定了该泛型Generic的指定类型为String。
所以要给泛型Generic的属性Name赋值，就需要赋值字符串类型的值。
|
1
2
3
4
5
|
public
static
void
Excute()
{
Generic<String> gs =
new
Generic<String>();
gs.Name =
"Kiba518"
;
}
|
下面代码定义了一个Int类型的泛型Generic。
|
1
2
3
4
5
|
public
static
void
Excute()
{
Generic<
int
> gs =
new
Generic<
int
>();
gs.Name = 518;
}
|
泛型的默认值
泛型的默认值，如下面代码所示。需要使用default(T)来赋值。
不管泛型到底是String,int,bool或者是一个Class类型，都可以被自动赋值。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
static
void
Excute()
{
Generic<
int
> gs =
new
Generic<
int
>();
gs.Name = 518;
Generic<Task> gsTask =
new
Generic<Task>();
gsTask.Name =
new
Task(()=> {
Console.WriteLine(
"Kiba518"
);
});
}
public
class
Generic<T>
{
public
T Name =
default
(T);
}
|
泛型的约束
在泛型类中，有个特别的约束可供我们使用。
当我们不显示的声明时，这个约束不存在。但当我们显示的声明的时候，这个约束就会执行。
下面，我们来看看这个特别的约束。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
static
void
Excute()
{
Generic<FanXing> gFanXing =
new
Generic<FanXing>();
Generic<Base> gFanXingBase =
new
Generic<Base>();
//Generic<string> gs = new Generic<string>(); 这样定义会报错
}
public
class
Generic<T>
where
T : Base
{
public
T Name =
default
(T);
}
public
class
Base
{
public
string
Name {
get
;
set
; }
}
public
class
FanXing : Base
{
public
new
string
Name {
get
;
set
; }
}
|
如上面代码所示，【where T : Base】就是这个特别的约束。
当显示声明这个约束的时候，定义会限制泛型的类型。
什么是限制泛型的类型呢？
很简单，泛型T，是泛指某一个类型。我们在定义泛型类时，还需显示的指定类型，此时我们显示指定的类型，要受这个限制。
这个限制就是指【where T : Base】。
它的限制是，要求我们指定的类型T必须是Base，或者该类型继承自Base，如FanXing类。
泛型的函数
在C#中，泛型不仅可以用于类，还可以直接用于函数。
具体使用方式如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public
static
void
Excute()
{
GenericFunc gf =
new
GenericFunc();
gf.FanXingFunc<FanXing>(
new
FanXing() { Name=
"Kiba518"
});
}
public
class
GenericFunc
{
public
void
FanXingFunc<T>(T obj)
{
Console.WriteLine(obj.GetType());
}
}
|
很简单，调用泛型函数的时候，指定泛型函数的[指定类型]即可。
但是，这里我们发现一个问题，那就是，在泛型函数里，使用泛型对象的时候，我们发现对象都是object类型的。
那我们如果想使用泛型对象里的属性和方法时，要怎么办呢？
也很简单，反射就可以了。
下面我们添加一个反射函数GetPropertyValue，专门用来获取属性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
GenericFunc
{
public
void
FanXingFunc<T>(T obj)
{
var
name = GetPropertyValue(obj,
"Name"
);
Console.WriteLine(name);
}
public
object
GetPropertyValue(
object
obj,
string
name)
{
object
drv1 = obj.GetType().GetProperty(name).GetValue(obj,
null
);
return
drv1;
}
}
|
输出结果如下：
这样我们就得到了我们想要的结果，如果想使用泛型类里的函数，道理也一样，只需要用反射来调用即可。
结语
看到这里，有些同学可能会觉得泛型很复杂，连使用其对象下的属性，都得反射，太繁琐了，还不如不用呢。
有这样想法的同学，心里想想就好了，如果对老司机这么说，他肯定会内心默默的微笑，然后对你说，你想的没错。
然后，你就没有然后了。
泛型的应用，开篇已经说了，主要用在提高代码的可重用性、类型安全性和效率上。
如果只是定义一个类，调用一个属性，那泛型的存在就是鸡肋。
但事实上，我们的系统永远只有更复杂，更复杂，更复杂。因此泛型才有了用武之地。
----------------------------------------------------------------------------------------------------
注：此文章为原创，欢迎转载，请在文章页面明显位置给出此文链接！
若您觉得这篇文章还不错，请点击下右下角的【推荐】，非常感谢！
C#语法——await与async的正确打开方式
C#5.0推出了新语法，await与async，但相信大家还是很少使用它们。关于await与async有很多文章讲解，但有没有这样一种感觉，你看完后，总感觉这东西很不错，但用的时候，总是想不起来，或者不知道该怎么用。
为什么呢？我觉得大家的await与async的打开方式不正确。
正确的打开方式
1、await 只能在标记了async的函数内使用。
2、await 等待的函数必须标记async。
有没有感觉这是个循环？没错，这就是个循环。这也就是为什么大家不怎么用他们的原因。这个循环很讨厌，那么怎么破除这个循环呢？
【很简单，await等待的是线程，不是函数。】
不理解吗？没关系，接着看下去。
下面从头来讲解，首先看这么一组对比
|
1
2
3
4
5
6
7
8
|
public
static
int
NoAsyncTest()
{
return
1;
}
public
static
async Task<
int
> AsyncTest()
{
return
1;
}
|
async Task<int>等于int
这意味着我们在正常调用这两个函数时，他们是等效的。那么用async Task<int>来修饰int目的是什么呢？
目的是为了让这个方法这样被调用 await AsyncTest()，但直接这样调用，并不会开启线程，那这样费劲的修饰是不是就没什么意义了呢。
当然不是，那什么时候会让 await AsyncTest()有意义呢？
我们接着往下看，修改AsyncTest如下。然后，此时再调用await AsyncTest()，你会神奇的发现，依然没有卵用。。。
Excute方法正常执行，而AsyncTest内运行的线程，自己执行自己的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public
static
async
void
Excute()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 开始 Excute "
+ DateTime.Now);
await AsyncTest();
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 结束 Excute "
+ DateTime.Now);
}
public
static
async Task<
int
> AsyncTest()
{
Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run1 "
+ DateTime.Now);
Thread.Sleep(1000);
});
return
1;
}
|
别着急，我们稍作调整，在线程后面增加.GetAwaiter().GetResult()。这句话是干什么用的呢？是用来获取线程返回值的。
这个逻辑是这样的，如果想要获取线程返回结果，就自然要等待线程结束。
运行一下，我们将看下面的结果。
|
1
2
3
4
5
6
7
8
9
|
public
static
async Task<
int
> AsyncTest()
{
Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run1 "
+ DateTime.Now);
Thread.Sleep(1000);
}).GetAwaiter().GetResult();
return
1;
}
|
但是，好像await AsyncTest();还是没启作用。没错，事实就是，他真的不会起作用。。。
那么怎么才能让他起作用呢？
首先，我们定义一个普通函数，他的返回值是一个Task，然后我们得到Task后，运行它，再用await等待这个Task。
于是我们就得到这样的结果。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
static
async
void
Excute()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 开始 Excute "
+ DateTime.Now);
var
waitTask = AsyncTestRun();
waitTask.Start();
int
i = await waitTask;
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" i "
+ i);
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 结束 Excute "
+ DateTime.Now);
}
public
static
Task<
int
> AsyncTestRun()
{
Task<
int
> t =
new
Task<
int
>(() => {
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run1 "
+ DateTime.Now);
Thread.Sleep(1000);
return
100;
});
return
t;
}
|
如图，这样写await AsyncTest();就起作用了。
所以，还是那句话，await等待的是线程，不是函数。
但在图里，我们发现很奇怪的一点，结束Excute也是线程3，而不是线程1。也就是说，Await会对线程进行优化。
下面看下两组代码的对比，让我们就更清楚的了解下Await。
第一组，使用await等待线程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public
static
async
void
Excute()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 开始 Excute "
+ DateTime.Now);
await SingleAwait();
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 结束 Excute "
+ DateTime.Now);
}
public
static
async Task SingleAwait()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" AwaitTest开始 "
+ DateTime.Now);
await Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run1 "
+ DateTime.Now);
Thread.Sleep(1000);
});
await Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run2 "
+ DateTime.Now);
Thread.Sleep(1000);
});
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" AwaitTest结束 "
+ DateTime.Now);
return
;
}
|
第二组，使用等待线程结果，等待线程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public
static
async
void
Excute()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 开始 Excute "
+ DateTime.Now);
await SingleNoAwait();
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" 结束 Excute "
+ DateTime.Now);
}
public
static
async Task SingleNoAwait()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" SingleNoAwait开始 "
+ DateTime.Now);
Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run1 "
+ DateTime.Now);
Thread.Sleep(1000);
}).GetAwaiter().GetResult();
Task.Run(() =>
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" Run2 "
+ DateTime.Now);
Thread.Sleep(1000);
}).GetAwaiter().GetResult();
Console.WriteLine(Thread.CurrentThread.GetHashCode() +
" SingleNoAwait结束 "
+ DateTime.Now);
return
;
}
|
可以明确的看到，第二组，线程重新回到了主线程1中，而第一组，已经被优化到了线程4中。
await是一种很便捷的语法，他的确会让代码简洁一些，但他主动优化线程的功能，如果不了解就使用，可能会导致一些奇怪的BUG发生。
这也是官方为什么只提供了await调用服务的例子，因为，在程序内调用，await还是要了解后，再使用，才安全。
----------------------------------------------------------------------------------------------------
C#线程安全使用（五）
这是线程安全的最后一篇了，主要介绍CancellationToken的多种应用。
1,ThreadPool直接启动线程，传递CancellationToken。
2,Task启动线程，传递CancellationToken。Task传递方式分为两种，一种通过Task的参数进行传递，另一种通过向线程内传递对象的方式传递CancellationToken。
3,CancellationToken的回调函数应用。
话不多说，请看代码。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"当前线程{0},当前状态{1}"
, Thread.CurrentThread.GetHashCode(), Thread.CurrentThread.ThreadState);
//使用线程池创建线程，然后取消线程
CancelWithThreadPoolMiniSnippet();
}
static
CancellationTokenSource cts =
new
CancellationTokenSource();
static
CancellationToken token = cts.Token;
static
void
CancelWithThreadPoolMiniSnippet()
{
Console.WriteLine(
"当前线程{0},当前状态{1}"
, Thread.CurrentThread.GetHashCode(), Thread.CurrentThread.ThreadState);
#region 使用QueueUserWorkItem的构造函数，传递cts.Token,但我不喜欢这个模式 跟踪不了状态
//ThreadPool.QueueUserWorkItem(new WaitCallback(DoSomeWork), ctn);
#endregion
#region 使用传递参数的模式 传递CancellationToken，这里的cts.Token是作为Action的参数传递的
//var action = new Action<object>(DoSomeWork);
//Task t = new Task(action, ctn);
//t.Start();
//Console.WriteLine("开始，当前线程{0},当前状态{1}", t.GetHashCode(), t.Status);
#endregion
#region 使用Task的构造函数，传递cts.Token,但CancellationTokenSource要弄成全局变量，否则方法找不到，就取消不了。
//Task t = new Task(Work, cts.Token);
//t.Start();
#endregion
#region 注册回调函数，当CancellationTokenSource.Cancel()执行后，调用回调函数
token.Register(CallBack,
true
);
//注册回调函数
Task t =
new
Task(Work);
t.Start();
#endregion
Thread.SpinWait(5000000);
cts.Cancel();
Console.WriteLine(
"结束，当前线程{0},当前状态{1}"
, t.GetHashCode(), t.Status);
Console.Read();
}
static
void
DoSomeWork(
object
obj)
{
CancellationToken token = (CancellationToken)obj;
for
(
int
i = 0; i < 100000; i++)
{
Console.WriteLine(i);
// Simulating work.
//Thread.SpinWait(5000000);
if
(token.IsCancellationRequested)
{
break
;
}
}
}
static
void
Work()
{
for
(
int
i = 0; i < 100000; i++)
{
Console.WriteLine(i);
if
(token.IsCancellationRequested)
{
break
;
}
}
}
static
void
CallBack()
{
Console.WriteLine(
"I'm call back!"
);
}
}
|
代码内执行结果如下，该结果为CancellationToken的回调函数应用：
到此NET Framework4.0里的线程安全就都讲完了。。。。。。。
虽然第一篇文章是2013年，虽然历时近五年，但请相信我，代码早在五年前就已经写完啦。只是我一直一直一直没配文字发出来。。。。。。
不过，也可能是最近写文字的能力有所提升，所以就完成了四和五。
不然这线程安全的文章可能还要拖。。。。。。。。哈哈
在NET Framework4.6里，微软提供了async和await语法，也是有关线程安全，我将会在新的语法相关文章里讲解async和await的用法。
----------------------------------------------------------------------------------------------------
C#语法——元组类型
我们现在使用的C#语法已经可以满足日常的开发需求，但C#语法还在进行版本的更新，在创造更多更优秀的语义来让我们使用。这里介绍一下C#5.0里的提供的语法——元组。
在C#中定义Tuple对象，转到定义查看，我们会看到如下代码
#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 // C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6\mscorlib.dll #endregion
即该语法在.Net Framework4框架中已经可以支持了。
元组Tuple是一种数据结构，具有特定数量和元素序列。什么意思呢？就是元组是可以存贮多种类型的对象，可以想象一下当一个函数拥有多个不同类型的返回值时，我们除了定义了一个返回值以外，还要定义多个out或ref类型返回值才能解决这个需求；当然我们也可以定义一个对象保存多个返回值。但现在我们多了一个解决方案，定义返回值为一个元组，就解决了一切。
元组Tuple是可以存贮多种类型的数据的。NET Framework 直接支持具有 1 到 7 元素的元组。 此外，您可以创建由嵌套中的元组对象的元组的八个或多个元素Rest属性Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>对象。
元组常用四种方法︰
1，用来表示一组数据。 例如，一个元组可以表示的数据库记录，并且其组件可以表示每个字段的记录。
2，若要提供轻松访问和数据集的操作。
3，out参数 （在 C# 中) 或ByRef参数 （在 Visual Basic 中)。
4，若要将多个值传递给通过单个参数的方法。 例如，Thread.Start(Object)方法只有一个参数，允许你提供一个线程在启动时执行的方法的值。如果你提供Tuple<T1, T2, T3>对象作为方法自变量，则可以提供有三个项的数据的线程的启动例程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
class
Program
{
static
void
Main(
string
[] args)
{
var
tuple =
new
Tuple<
string
,
int
,
int
,
int
>(
"Kiba"
, 00001, 00002,
00003);
Console.WriteLine(tuple.Item1);
Console.WriteLine(tuple.Item2);
Console.WriteLine(tuple.Item3);
Console.WriteLine(tuple.Item4);
var
tupleCalss =
new
Tuple<A, B>(
new
A(),
new
B());
Console.WriteLine(tupleCalss.Item1.Name);
Console.WriteLine(tupleCalss.Item2.Name);
Console.ReadKey();
}
}
public
class
A
{
public
string
name =
"A"
;
public
string
Name {
get
=> name;
set
=> name = value; }
}
public
class
B
{
public
string
Name =
"B"
;
}<br>}<br><br><br>
|
输出结果
Kiba
1
2
3
A
B
【PS：这里使用的目标框架是.net framework 4.0 ，我们可以看到属性的声明如下，即4.0已经支持=>模式的属性设置了。】
|
1
2
3
|
public
string
name =
"A"
;
public
string
Name {
get
=> name;
set
=> name = value; }
|
好好耕耘 redis和memcached的区别
观点一：
1、Redis和Memcache都是将数据存放在内存中，都是内存数据库。不过memcache还可用于缓存其他东西，例如图片、视频等等；
2、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储；
3、虚拟内存--Redis当物理内存用完时，可以将一些很久没用到的value 交换到磁盘；
4、过期策略--memcache在set时就指定，例如set key1 0 0 8,即永不过期。Redis可以通过例如expire 设定，例如expire name 10；
5、分布式--设定memcache集群，利用magent做一主多从;redis可以做一主多从。都可以一主一从；
6、存储数据安全--memcache挂掉后，数据没了；redis可以定期保存到磁盘（持久化）；
7、灾难恢复--memcache挂掉后，数据不可恢复; redis数据丢失后可以通过aof恢复；
8、Redis支持数据的备份，即master-slave模式的数据备份；
9、mongodb和memcached不是一个范畴内的东西。mongodb是文档型的非关系型数据库，其优势在于查询功能比较强大，能存储海量数据。mongodb和memcached不存在谁替换谁的问题。
观点二：
Redis与Memcached的区别
如果简单地比较Redis与Memcached的区别，大多数都会得到以下观点：
1 Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。
2 Redis支持数据的备份，即master-slave模式的数据备份。
3 Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
在Redis中，并不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别（我个人是这么认为的）。
Redis 只会缓存所有的key的信息，如果Redis发现内存的使用量超过了某一个阀值，将触发swap的操作，Redis根据“swappability = age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再将这些key对应的value持久化到磁 盘中，同时在内存中清除。这种特性使得Redis可以保持超过其机器本身内存大小的数据。当然，机器本身的内存必须要能够保持所有的key，毕竟这些数据 是不会进行swap操作的。
同时由于Redis将内存中的数据swap到磁盘中的时候，提供服务的主线程和进行swap操作的子线程会共享这部分内存，所以如果更新需要swap的数据，Redis将阻塞这个操作，直到子线程完成swap操作后才可以进行修改。
可以参考使用Redis特有内存模型前后的情况对比：
VM on: 300k keys, 4096 bytes values: 73M used
VM off: 1 million keys, 256 bytes values: 430.12M used
VM on: 1 million keys, 256 bytes values: 160.09M used
VM on: 1 million keys, values as large as you want, still: 160.09M used
当 从Redis中读取数据的时候，如果读取的key对应的value不在内存中，那么Redis就需要从swap文件中加载相应数据，然后再返回给请求方。 这里就存在一个I/O线程池的问题。在默认的情况下，Redis会出现阻塞，即完成所有的swap文件加载后才会相应。这种策略在客户端的数量较小，进行 批量操作的时候比较合适。但是如果将Redis应用在一个大型的网站应用程序中，这显然是无法满足大并发的情况的。所以Redis运行我们设置I/O线程 池的大小，对需要从swap文件中加载相应数据的读取请求进行并发操作，减少阻塞的时间。
redis、memcache、mongoDB 对比
从以下几个维度，对redis、memcache、mongoDB 做了对比，欢迎拍砖
1、性能
都比较高，性能对我们来说应该都不是瓶颈
总体来讲，TPS方面redis和memcache差不多，要大于mongodb
2、操作的便利性
memcache数据结构单一
redis丰富一些，数据操作方面，redis更好一些，较少的网络IO次数
mongodb支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富
3、内存空间的大小和数据量的大小
redis在2.0版本后增加了自己的VM特性，突破物理内存的限制；可以对key value设置过期时间（类似memcache）
memcache可以修改最大可用内存,采用LRU算法
mongoDB适合大数据量的存储，依赖操作系统VM做内存管理，吃内存也比较厉害，服务不要和别的服务在一起
4、可用性（单点问题）
对于单点问题，
redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整个快照,无增量复制，因性能和效率问题，
所以单点问题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制。
一种替代方案是，不用redis本身的复制机制，采用自己做主动复制（多份存储），或者改成增量复制的方式（需要自己实现），一致性问题和性能的权衡
Memcache本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的hash或者环状的算法，解决单点故障引起的抖动问题。
mongoDB支持master-slave,replicaset（内部采用paxos选举算法，自动故障恢复）,auto sharding机制，对客户端屏蔽了故障转移和切分机制。
5、可靠性（持久化）
对于数据持久化和数据恢复，
redis支持（快照、AOF）：依赖快照进行持久化，aof增强了可靠性的同时，对性能有所影响
memcache不支持，通常用在做缓存,提升性能；
MongoDB从1.8版本开始采用binlog方式支持持久化的可靠性
6、数据一致性（事务支持）
Memcache 在并发场景下，用cas保证一致性
redis事务支持比较弱，只能保证事务中的每个操作连续执行
mongoDB不支持事务
7、数据分析
mongoDB内置了数据分析的功能(mapreduce),其他不支持
8、应用场景
redis：数据量较小的更性能操作和运算上
memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写少，对于数据量比较大，可以采用sharding）
MongoDB:主要解决海量数据的访问效率问题
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace 正确打开方式 { class Program { public static async void Excute() { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now); var waitTask = AsyncTestRun(); //表示一个可以返回值的异步操作。 waitTask.Start(); //int i = 0; int i = await waitTask; Console.WriteLine(Thread.CurrentThread.GetHashCode() + " i " + i); Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute " + DateTime.Now); Console.ReadKey(); } public static Task<int> AsyncTestRun() { Task<int> t = new Task<int>(() => { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now); Thread.Sleep(1000); return 100; }); return t; } public static async Task<int> AsyncTest() { Task.Run(() => //将在线程池上运行的指定工作排队，并返回该工作的任务句柄。 {//创建了新线程 Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now); Thread.Sleep(1000); }).GetAwaiter().GetResult(); return 1; } static void Main(string[] args) //错误 1 “正确打开方式.Program.Main(string[])”: 入口点不能用“async”修饰符标记 { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now); //AsyncTest(); //正常调用不会创线程 //AsyncTest(); //出现三行 说明 创建了 一个线程 、、出现四行 说明 创建了 两个个线程 五行 //但是，好像await AsyncTest();还是没启作用。没错，事实就是，他真的不会起作用。。。 //Excute(); Console.WriteLine("--"); Console.WriteLine("--"); //Excute2(); Excute3(); Console.ReadKey(); } public static async void Excute2() { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute2 " + DateTime.Now); await SingleAwait(); //等待线程结束 然后执行后面的 Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute2 " + DateTime.Now); } public static async Task SingleAwait() { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " AwaitTest开始 " + DateTime.Now); await Task.Run(() => //await 等待线程完成 { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now); Thread.Sleep(1000); }); await Task.Run(() => //Await会对线程进行优化。 { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run2 " + DateTime.Now); Thread.Sleep(1000); }); Console.WriteLine(Thread.CurrentThread.GetHashCode() + " AwaitTest结束 " + DateTime.Now); return; } public static async void Excute3() { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute3 " + DateTime.Now); await SingleNoAwait(); Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute3 " + DateTime.Now); } public static async Task SingleNoAwait() { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " SingleNoAwait开始 " + DateTime.Now); Task.Run(() => { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now); Thread.Sleep(1000); }).GetAwaiter().GetResult(); //用来获取线程返回值的。这个逻辑是这样的，如果想要获取线程返回结果，就自然要等待线程结束。 Task.Run(() => { Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run2 " + DateTime.Now); Thread.Sleep(1000); }).GetAwaiter().GetResult(); Console.WriteLine(Thread.CurrentThread.GetHashCode() + " SingleNoAwait结束 " + DateTime.Now); return; } } }
385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
