使用InternalsVisibleTo给assembly添加“友元assembly”[转]

C#的internal关键字可以使标记的方法,字段或者属性等等只能在当前assembly内部使用,那么如果其他的assembly需要使用这个internal的方法的时候怎么办呢?.NET提供了一种类似于C++中的友元类的方式来完成这个功能,那就是使用InternalsVisibleTo。

这种情况常见于做测试的时候,需要另外一个项目来测试项目中的internal方法所标记的功能,所以有了InternalsVisibleTo,我们就不用为了做单元测试而把一个本不该公开的方法改为public了.

使用InternalsVisibleTo还有一些需要注意的地方,特别是PublicKey不太容易弄的明白,下面先来说说这个InternalsVisibleTo该怎么使用:

先来说明一下前提:Project1是功能项目,Project1.Test (assembly name: Project1.Test.dll)是为做Project1的测试工程。

1. 打开Project1的Assembly.cs文件,在文件的末尾加上这样一句话:

[assembly: InternalsVisibleTo("Project1.Test, PublicKey=******")]

其中PublicKey=******应该替换成Project1.Test.dll的public key,至于如何获取PublicKey,请看文章末尾的Notes部分.

2. 确认namespace: System.Runtime.CompilerServices 添加到了Assembly.cs的namespace引用中,因为InternalsVisibleTo位于命名空间System.Runtime.CompilerService中。

Notes:

1. 如何获取PublicKey?

A: 在命令行下,使用sn -Tp Project1.Test.dll就可以看到PublicKey和PublicKeyToken

2. 如果Project1是个strong-named的项目,那么InternalsVisibleTo必须指定PublicKey,所以Project1.Test也必须使用强签名才能正确使用InternalsVisibleTo, 不然编译会出错,如果Project1没有使用强签名,那么Project1.Test也不必使用强签名,而且在使用InternalsVisibleTo的时候只需要程序集的名字就可以了,不需要设置PuklicKey。

C# 2 之 #pragma warning 警告禁用指令[转]

今天我们来看点不一样的。

Part 1 早期禁用编译器警告信息


还记得我们在学习语言配置的时候用到的 .csproj  格式的文件吗?这个文件专门对项目设置配置信息,比如 C# 的语言版本之类的。在这个文件里,我们还可以配置取消编译器警告的信息。

我们先来回忆一下编译器警告和编译器错误。编译器警告是一个提示信息,默认情况用的是绿色波浪线表示代码段,表达这段代码有一些运行期间无伤大雅,但不符合规范使用的信息。例如下面的代码:

可以从代码里看出,此时 hello 变量只定义了但没有使用,因此编译器会对这样的错误使用给出编译器警告。但是这样的错误不是致命错误,因为它只是定义了没使用,也不影响程序的正常执行。

编译器错误则是一个信息,表示代码具有严重错误或无法编译的致命错误信息。比如 C# 要求每一个语句要用分号结尾。但如果缺失分号,编译器会自动产生编译器错误信息。这样的代码是无法通过编译的。

编译器警告是不重要的错误,但多起来也挺烦人的。有些时候部分编译器警告是可以忽略掉的,因此满篇都是绿色的波浪线看着也挺不舒服的。因此我们可以对这些编译器警告信息予以忽略操作。让编译器不再对这些错误产生警告。

办法是这样的:我们打开项目的 .csproj 为后缀名的配置文件,它一般都长这样:

<PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    ...
</PropertyGroup>


我们在 标签里,在和 标签同级别的地方配上 标签,里面写 CS0219:

  <PropertyGroup>
      <TargetFramework>net6.0</TargetFramework>
      ...
  • CS0219

    这里 标签表示的是,整个项目需要禁用掉哪些警告信息,下次编译器就不会对这些信息报错了。里面写的是警告禁用的编号代码。我们回到最开始那个图片上,你可以看到,CS0219 后跟上了错误的信息内容和解释文字,而这个 CS0219,就是编译器对这些警告或错误信息给出的唯一编号。你只需要把对应的错误编号写到 里后,所有 CS0219 错误的信息,编译器就不再会给出了。

回到代码:

你会发现,缺失警告的波浪线消失了。这个就是配置和取消警告信息的过程。

但是可以发现,这样的配置有一个严重的弊端:它是对整个项目起效的。它无法对文件为单位取消警告信息,整个项目都取消的话,这个范围未免也有点太大了一些。所以,原生的 C# 并不支持文件为单位的警告信息取消。

另外,Visual Studio 定义了四种编译器报错的级别,分别是 Hidden(隐藏级别报错)、Info(信息级别报错)、Warning(警告级别报错)和 Error(错误级别报错)。而绿色波浪线的错误信息级别是 Warning 级别。而 Visual Studio 还定义了两种级别,一个叫 Hidden,一个叫 Info。Hidden 级别的编译器信息,不会用任何的标记来标记错误书写的代码段,唯一能发觉到它的存在的办法是,把你的代码光标(就是标识你书写代码到哪里的那个文字间的闪烁竖线条)放在这个所在行上,然后你会在代码所在行的行号旁看到一个灯泡图标,里面可以看到对应的信息;而 Info 级别会有标记错误代码段落的标记,不过它不是绿色也不是红色波浪线,而是灰色的四个小圆点,标识你的错误代码段开头的位置上。这样的标记很不容易引起注意,因为它比起编译器警告信息来说还要低一个级别,这类警告信息,你改不改正都无伤大雅。而比 Info 大一个级别的才是编译器警告(Warning 级别),最后才是编译器错误(Error 级别)。

Part 2 #pragma warning disable 指令


C# 2 为了解决这样的错误提示消除过程无法实现的问题,诞生了新的语句:#pragma warning disable 指令。

pragma warning disable 指令是一个组合单词的指令,也就是说,pragma、warning 和 disable 这三个单词都必须一起写出来,而且必须是先 pragma 后 warning,最后是 disable;另外,在 pragma 前面,还需要加上预处理指令的井号 # 标记。

我们把它当成是一个预处理指令一样的使用就行。不过这个预处理指令和 #region 还有 #endregion 类似,它可以用于任何代码行上。以前的 #if 只能放在文件开头,或者前面带有一些 using 指令什么的。但 #pragma warning disable 指令可以写在任何位置。唯一需要注意的是,它是预处理指令,因此必须单独占据一行;也就是说你不能对 #pragma warning disable 这三个单词的每两个单词中间插入换行,这是唯一需要注意的。

比如,给出一个简单的示例程序:

pragma warning disable IDE0059

pragma warning disable CS0219

pragma warning disable IDE0005

using System;

static class Program
{
static void Main()
{
string hello = “Hello!”;
}
}
其中:

IDE0059 信息:对一个变量的赋值没有意义;

CS0219 信息:变量定义了但没有使用过;

IDE0005 信息:using 指令没有使用过。

你可以使用这个语法来对它们的错误信息进行消除。当然,C# 也允许你写在一行里:

pragma warning disable IDE0059, CS0219, IDE0005

using System;

static class Program
{
static void Main()
{
string hello = “Hello!”;
}
}
用逗号分隔每一个编号即可。

Part 3 #pragma warning restore 指令


当然,#pragma warning 也不是必须跟 disable。C# 2 为了更为灵活地控制编译器警告报错的过程,该指令还有一个写法:#pragma warning restore。它表示,既报错禁用后,恢复对指定编号的报错。

pragma warning restore 的语法和 #pragma warning disable 的语法完全一样,即后面跟上的是错误编号(如果是多个错误编号的话,用逗号分开),但 #pragma warning restore 一般用在它的前面已经出现过 #pragma warning disable 的同编号错误警告的时候。举个例子,我现在有这样的代码:

它表示计算一个数字的阶乘。但是这个方法我们尚未使用过,因此我们会在方法的上方插入一个 #pragma warning disable 的警告禁用指令。不过,我如果在 Factorial 方法下面还有别的代码的话,这个警告禁用的范围就超出了我们预想的范围:我们只想要禁用掉 Factorial 这一个方法的使用性的报错,而别的方法不影响。

我们可以这么写:

pragma warning disable IDE0051

private static long Factorial(int n)

pragma warning restore IDE0051

{
long result = 1;
for (int i = 1; i <= n; i++)
result *= i;

return result;

}
我们可在报错的 Factorial 方法签名所在行的上下方各插入一行指令。上面是报错,下面是 restore 恢复报错。这里的 IDE0051 就是表示“方法没有使用过”的报错信息。

有人会问,为什么 restore 这个指令写在第 3 行而不是第 10 行后?因为编译器分析和报错只位于整个方法的签名上(你可以看到前面给出的图片,四个小圆点只出现在 Factorial 这个方法名上,而不是整个方法都标上了灰色的四个小圆点。所以,我们只需要插入到这里即可。当然了,你写在第 10 行后也是可以的,也没有错误就是了。

Part 4 #warning 的禁用


C# 早期还有一个叫做 #warning 的指令,它用来控制和表示在当前位置直接产生编译器警告信息。

using System;

static class Program
{
static void Main()
{
}

private static string HelloTo(string name)
{
    return string.Format("Hello, {0}!", name);
}

warning Deprecated code block.

private static string Hello()
{
    return "Hello!";
}

}
比如这样的代码,我们可以看到第 14 行有一个 #warning 指令。我们此时可以直接在第 14 行获得一个编译器警告信息。不过,如果你要禁用这段代码的错误,这里就需要了解一下,#warning 指令的报错机制了。

warning 占用了编译器警告编号是 CS1030。也就是说,你写的 #warning 默认都会产生编号为 CS1030 的编译器警告信息。如果你要想禁用掉,使用 #pragma warning disable CS1030 即可。

using System;

class Program
{
static void Main()
{
}

private static string HelloTo(string name)
{
    return string.Format("Hello, {0}!", name);
}

pragma warning disable CS1030

warning Deprecated code block.

pragma warning restore CS1030

private static string Hello()
{
    return "Hello!";
}

}
比如这样。当然了,毕竟是我们自己临时自定义的警告信息,我们也不建议对自己添加的警告信息再次取消掉它的报错。

Part 5 简记 CS 系列错误编号


Visual Studio 发展到现在,拥有众多的编译器分析出来的编号代码。其中常见的有这些:

CS 系列:C# 语言自身派生的基本语法分析的错误和警告信息;

IDE 系列:和 Visual Studio 绑定的、和你书写的代码可以产生交互的编译器警告信息;

CA 系列:官方提供的、补充的编译器错误和警告信息。

当然还有一些别的,什么 RS 开头的啊,SA 开头的,DA 开头等等的系列。不过这里我们要说的是 CS 开头的。CS 是 C# 语法分析的结果导致的唯一编号序列,它们在使用 #pragma warning 指令的时候,可以不写 CS 前缀,比如 CS1030 可以直接记作 1030,等等。

比如最开始的禁用的代码:

pragma warning disable IDE0059, 219, IDE0005

using System;

static class Program
{
static void Main()
{
string hello = “Hello!”;
}
}
这个 CS0219 可以直接记作 0219 或 219。但别的,都必须带上开头的字母。

Part 6 不能禁用掉编译器错误


编译器错误一般而言是无法禁用的,原因很简单:比如你写的忘了分号的语法错误,编译器肯定是不让编译通过的。因此,#pragma warning 肯定无法使用到这种场合上。它属于严重的错误,不属于去掉编译器警告就能消除掉的错误类型。

作者:SunnieShine
原文地址: https://www.bilibili.com/read/cv15187637/

MongoDB C# Driver 快速入门指南

这是MongoDB driver的第一部分。在这一部分,你可以看到如何去执行一些数据库的基本CRUD(C-创建,R-读取,U-更新,D-删除)操作。

连接

以下展示了三种连接到MongoDB远程服务器和本地服务器的方式 :

// 连接到单实例MongoDB服务
// 这种连接方式不会自动检测连接的节点是主节点还是复制集的成员节点
var client = new MongoClient();

// 或者使用string连接本地服务器,localhost=127.0.0.1,连接到单实例
var client = new MongoClient("mongodb://localhost:27017");

// 连接到复制集(多节点)
var client = new MongoClient("mongodb://localhost:27017,localhost:27018,localhost:27019");

客户端实例现在可以拥有连接到连接字符串中指定的服务器或服务器的连接池。

MongoClient

MongoClient 实例实际上表示一个连接数据库的连接池;

你仅仅只需要一个MongoClient 类实例,即使在多线程情况下;

标注:
实际上,你只需要为给定的集群创建一个MongoClient实例,并在应用程序中使用它。但是,如果连接字符串是相同的,那么创建多个MongoClient将仍然共享相同的连接池。

Get a Database

获取一个数据库实例,列举数据库的名称可以通过client中的GetDatabase方法,在数据库存在的情况下,该方式都是可行的。它将在首次被调用时创建。

var database = client.GetDatabase("foo");

现在,database变量保存了对数据库“foo”的引用.

Get a Collection

获取一个集合实例,列举集合的名称可以通过database中GetCollection<TDocument>.在集合存在的情况下,它将在首次被调用时创建。

var collection = database.GetCollection<BsonDocument>("bar");

现在,collection变量保存了对数据库“foo”下“bar”集合的引用.

标注:
泛型参数TDocument表示集合中存在的模式,使用一个BsonDocument来表示没有预定的模式。

Insert a Document

一旦你拥有了collection实例,你就可以插入一个文档到集合中。例如,考虑下面的JSON文档,它是一个包含了一个字段信息的嵌入式文档。

{
     "name": "MongoDB",
     "type": "database",
     "count": 1,
     "info": {
         x: 203,
         y: 102
     }
}

你可以使用.NET driver中的BsonDocument类创建这个文档,方式如下:

var document = new BsonDocument
{
    { "name", "MongoDB" },
    { "type", "Database" },
    { "count", 1 },
    { "info", new BsonDocument
        {
            { "x", 203 },
            { "y", 102 }
        }
    }
};

把这个文档插入到集合中,可以是使用InsertOne或者InsertOneAsync方法

collection.InsertOne(document);//同步
await collection.InsertOneAsycn(document);//异步

标注:
.NET driver 当前已全部支持异步操作。关于更多的async和await的信息,参见MSDN documentation
https://msdn.microsoft.com/en-us/library/hh191443.aspx
驱动中所有的API都已经同时支持同步和异步.

Insert Multiple Documents

插入多条数据到数据库,可以使用InsertMany或者InsertManyAsync两种方式.

// 生成 100 个counter从0~99递增的文档
var documents = Enumerable.Range(0, 100).Select(i => new BsonDocument("counter", i));

插入数据

collection.InsertMany(documnets);
await collection.InsertManyAsycn(documents);

Counting Documents

现在,我们插入了101个文档到数据库里面(100在循环中,首次插入1),我们可以核查这些数据,如果我们使用Count或者CountAsycn方法. 下面的代码应该可以使得count的值为101.

var count = collection.Count(new BsonDocument());
or
var count = await collection.CountAsync(new BsonDocument());

标注:
空的BsonDocument参数是一个过滤器。在这里,指的是要计算所有的文档.

Query the Collection

使用Find方法去集合中查询. 该方法会返回一个IFindFluent<TDocument, TProjection>实例,它提供一个接口链接find操作设置.

Find the First Document in a Collection

调用FirstOrDefault 或者FirstOrDefaultAsync 方法,可以获取集合的第一个文档.FirstOrDefault返回第一个文档或者null. 当你只需要一个匹配的文档或只对第一个文档感兴趣时,该方法非常有用.

下面的例子将会打印出再集合中查询出来的第一个文档:

var document = collection.Find(new BsonDocument()).FirstOrDefault();
Consloe.WriteLine(document.ToString());
var document = await collection.Find(new BsonDocument()).FirstOrDefaultAsync();
Console.WriteLine(document.ToString());

该例子将会打印出以下内容:

{ 
    "_id": ObjectId("5940f2b98198abd6a5eea7b1") },
    "name": "MongoDB", 
    "type": "database", 
    "count": 1,
    "info": { "x" : 203, "y" : 102 } 
}

元素 “id” 为 MongoDB 数据库自动添加到文档中,这是打印出来的内容与插入的内容不一致的原因。MongoDB数据库内部保留所有以 “_” 和 “$” 开头的字段名称.

Find All Documents in a Collection

使用ToList或者ToListAsycn方法可以检索到集合中的所有文档,当需要返回的文档比较少量时,该方法非常有用.

var documents = collection.Find(new BsonDocument()).ToList();
var documents = await collection.Find(new BsonDocument()).ToListAsync();

如果返回的文档数量比预期的大,可以使用通过迭代的方式进行处理。ForEachAsync将会为每个返回的文档调用一个回调。

await collection.Find(new BsonDocument()).ForEachAsync(d => Console.WriteLined(d));

如果使用的是同步的API,则要使用C#中的ToEnumerable抽象方法去迭代每个文档:

var cursor = collection.Find(new BsonDocument()).ToCursor();
foreach (var document in cursor.ToEnumerable())
{
    Console.WriteLine(document);   
}

上面的例子将会打印出相同的信息。更多的信息参见reference documention

Get a Single Document With a Filter

在一个集合中,我们可以创建一个筛选器传递给Find方法去获取一个文档的子集。例如,如果我们想查找“i”字段的值为71的文档,我们可以使用如下的方式:

var filter = Builders<BsonDocument>.Filter.Eq("i", 71);
var document = collection.Find(filter).First();
Console.WriteLine(document);
var document = await collection.Find(filter).FirstAsync();
Console.WriteLine(document);

以上应该仅打印出一个文档:

{ "_id" : ObjectId("5515836e58c7b4fbc756320b"), "i" : 71 }

标注:
使用 Filter,Sort 和 Projection 以简单和简洁的方式创建一个查询.

Get a Set of Documents With a Filter

我们也可以从集合中获取一组文档。例如,如果我们获取所有符合 i > 50 条件的文档,可以使用如下的方式:

var filter = Builders<BsonDocument>.Filter.Gt("i", 50);// Gt表示大于
var cursor = collection.Find(filter).ToCursor();
foreach (var document in cursor.ToEnumerable())
{
    Console.WriteLine(document);   
}
await collection.Find(filter).ForEachAsync(document => Console.WriteLine(document));

还可以限定一个范围查询,例如 50 < i <= 100;

var filterBuilder = Builders<BsonDocument>.Filter;
var filter = filterBuilder.Gt("i", 50) & filterBuilder.Lte("i", 100);//Lt表示小于,Lte表示小于等于
var cursor = collection.Find(filter).ToCursor();
foreach (var document in cursor.ToEnumerable())
{
    Console.WriteLine(document);   
}
await collection.Find(filter).ForEachAsync(document => Console.WriteLine(document));

Sorting Documents

我们可以通过调用 Sort 方法来创建一个排序匹配查询。在现有的 filter 构造方法下,我们可以使用 Descending 建立一个降序构造器来排序我们的文档:

var filter = Builders<BsonDocument>.Filter.Exists("i");
var sort = Builders<BsonDocument>.Sort.Descending("i");
var document = collection.Find(filter).Sort(sort).First();
var document = await collection.Find(filter).Sort(sort).FirstAsync();

Projecting Fields(映射字段)

很多时候,我们不需要文档中包含的所有字段,Projection 构造器可以在一个查询操作中构造映射字段。下面的例子中,我们排除了“_id”字段,并且输出第一个匹配的文档:

var projection = Builders<BsonDocument>.Projection.Exclude("_id");
var document = collection.Find(new BsonDocument()).Project(projection).First();
Console.WriteLine(document.ToString());
var document = await collection.Find(new BsonDocument()).Project(projection).FirstAsync();
Console.WriteLine(document.ToString());

Updating Documents

MongoDB 支持多种更新操作方式

更新最多一个文档(如果没有匹配筛选器,可能为零个文档),使用UpdateOne或者UpdateOneAsync去指定筛选器并更新匹配的文档。下面,我们更新筛选器为 i == 10 匹配的第一个文档,并将该文档 i 的值更新为110:

var filter = Builders<BsonDocument>.Filter.Eq("i", 10);
var update = Builders<BsonDocument>.Update.Set("i", 110);
collection.UpdateOne(filter, update);
await collection.UpdateOneAsync(filter, update);

更新筛选器匹配的所有文档,使用UpdateMany或者UpdateManyAsync方法。下面例子,将把所有 i < 100 匹配的文档中 i 的值增加 100。

var filter = Builders<BsonDocument>.Filter.Lt("i", 100);
var update = Builders<BsonDocument>.Update.Inc("i", 100);// Inc操作符表示:给i字段增加某个大小的值

var result = collection.UpdateOne(filter, update);

if (result.IsModifiedCountAvailable)
{
    Console.WriteLine(result.ModifiedCount);
}

var result = await collection.UpdateOneAsync(filter, update);

if (result.IsModifiedCountAvailable)
{
    Console.WriteLine(result.ModifiedCount);
}

更新方法返回的结果为UpdateResult,它提供关于该操作的信息,包括更新后修改的文档的数量。

标注:
根据MongoDB数据库的版本,某些特性可能无法使用。在这些情况下,我们已经尝试了检查是否有能力检查它们的可用性。

Deleting Documents

删除最多一个文档(如果没有匹配筛选器,可能为零个文档),使用 DeleteOne 或者DeleteOneAsync方法:

var filter = Builders<BsonDocument>.Filter.Eq("i", 110));
collection.DeleteOne(filter);
await collection.DeleteOneAsync(filter);

删除筛选器匹配的所有文档,使用DeleteMany 或者 DeleteManyAsync 方法。下面是删除所有 i >= 100 匹配的文档:

var filter = Builders<BsonDocument>.Filter.Gte("i", 100));// Gte表示大于等于

var result = collection.DeleteMany(filter);

Console.WriteLine(result.DeletedCount);

var result = await collection.DeleteManyAsync(filter);

Console.WriteLine(result.DeletedCount);

删除方法返回的结果为DeleteResult ,它提供关于该操作的信息,包括删除的文档数量。

Bulk Writes (批量操作)

Bulk 操作有两种类型:

有序Bulk操作
以有序的方式执行所有的操作,并且在首次遇到异常时抛出异常。

无序Bulk操作
执行所有的操作,并记录操作过程中的全部异常。无序的批量操作不能保证执行的顺序。
让我们看一看下面的两个关于有序和无序的操作例子:

var models = new WriteModel<BsonDocument>[] 
{
    new InsertOneModel<BsonDocument>(new BsonDocument("_id", 4)),
    new InsertOneModel<BsonDocument>(new BsonDocument("_id", 5)),
    new InsertOneModel<BsonDocument>(new BsonDocument("_id", 6)),
    new UpdateOneModel<BsonDocument>(
        new BsonDocument("_id", 1), 
        new BsonDocument("$set", new BsonDocument("x", 2))),
    new DeleteOneModel<BsonDocument>(new BsonDocument("_id", 3)),
    new ReplaceOneModel<BsonDocument>(
        new BsonDocument("_id", 3), 
        new BsonDocument("_id", 3).Add("x", 4))
};

// 1. 有序的批量操作 - 保证操作的顺序
collection.BulkWrite(models);

// 2. 无序的批量操作 - 无法保证操作的顺序
collection.BulkWrite(models, new BulkWriteOptions { IsOrdered = false });

异步

// 1. 有序的批量操作 - 保证操作的顺序
await collection.BulkWriteAsync(models);

// 2. 无序的批量操作 - 无法保证操作的顺序
await collection.BulkWriteAsync(models, new BulkWriteOptions { IsOrdered = false });

重要:
批量操作功能在MongoDB数据库版本为2.6及之前的版本不被推荐使用,在性能上有较大的影响。

C#格式化时间,货币

1、格式化货币(跟系统的环境有关,中文系统默认格式化人民币,英文系统格式化美元)

string.Format(“{0:C}”,0.2) 结果为:¥0.20 (英文操作系统结果:$0.20)

默认格式化小数点后面保留两位小数,如果需要保留一位或者更多,可以指定位数
string.Format(“{0:C1}”,23.15) 结果为:¥23.2 (截取会自动四舍五入)

格式化多个Object实例
string.Format(“市场价:{0:C},优惠价{1:C}”,23.15,19.82)

2、格式化十进制的数字(格式化成固定的位数,位数不能少于未格式化前,只支持整形)

string.Format(“{0:D3}”,23) 结果为:023

string.Format(“{0:D2}”,1223) 结果为:1223,(精度说明符指示结果字符串中所需的最少数字个数。)

3、用分号隔开的数字,并指定小数点后的位数

string.Format(“{0:N}”, 14200) 结果为:14,200.00 (默认为小数点后面两位)

string.Format(“{0:N3}”, 14200.2458) 结果为:14,200.246 (自动四舍五入)

4、格式化百分比

string.Format(“{0:P}”, 0.24583) 结果为:24.58% (默认保留百分的两位小数)

string.Format(“{0:P1}”, 0.24583) 结果为:24.6% (自动四舍五入)

5、零占位符和数字占位符

string.Format(“{0:0000.00}”, 12394.039) 结果为:12394.04

string.Format(“{0:0000.00}”, 194.039) 结果为:0194.04

string.Format(“{0:###.##}”, 12394.039) 结果为:12394.04

string.Format(“{0:####.#}”, 194.039) 结果为:194

下面的这段说明比较难理解,多测试一下实际的应用就可以明白了。
零占位符:
如果格式化的值在格式字符串中出现“0”的位置有一个数字,则此数字被复制到结果字符串中。小数点前最左边的“0”的位置和小数点后最右边的“0”的位置确定总在结果字符串中出现的数字范围。
“00”说明符使得值被舍入到小数点前最近的数字,其中零位总被舍去。

数字占位符:
如果格式化的值在格式字符串中出现“#”的位置有一个数字,则此数字被复制到结果字符串中。否则,结果字符串中的此位置不存储任何值。
请注意,如果“0”不是有效数字,此说明符永不显示“0”字符,即使“0”是字符串中唯一的数字。如果“0”是所显示的数字中的有效数字,则显示“0”字符。
“##”格式字符串使得值被舍入到小数点前最近的数字,其中零总被舍去。

6、日期格式化

string.Format(“{0:d}”,System.DateTime.Now) 结果为:2009-3-20 (月份位置不是03)

string.Format(“{0:D}”,System.DateTime.Now) 结果为:2009年3月20日

string.Format(“{0:f}”,System.DateTime.Now) 结果为:2009年3月20日 15:37

string.Format(“{0:F}”,System.DateTime.Now) 结果为:2009年3月20日 15:37:52

string.Format(“{0:g}”,System.DateTime.Now) 结果为:2009-3-20 15:38

string.Format(“{0:G}”,System.DateTime.Now) 结果为:2009-3-20 15:39:27

string.Format(“{0:m}”,System.DateTime.Now) 结果为:3月20日

string.Format(“{0:t}”,System.DateTime.Now) 结果为:15:41

string.Format(“{0:T}”,System.DateTime.Now) 结果为:15:41:50

更详细的说明请下面微软对此的说明或者上msdn上查询。

微软MSDN对string.format的方法说明:

名称 说明
String.Format (String, Object) 将指定的 String 中的格式项替换为指定的 Object 实例的值的文本等效项。
String.Format (String, Object[]) 将指定 String 中的格式项替换为指定数组中相应 Object 实例的值的文本等效项。
String.Format (IFormatProvider, String, Object[]) 将指定 String 中的格式项替换为指定数组中相应 Object 实例的值的文本等效项。指定的参数提供区域性特定的格式设置信息。
String.Format (String, Object, Object) 将指定的 String 中的格式项替换为两个指定的 Object 实例的值的文本等效项。
String.Format (String, Object, Object, Object) 将指定的 String 中的格式项替换为三个指定的 Object 实例的值的文本等效项。

标准数字格式字符串

格式说明符 名称 说明
C 或 c
货币
数字转换为表示货币金额的字符串。转换由当前 NumberFormatInfo 对象的货币格式信息控制。

精度说明符指示所需的小数位数。如果省略精度说明符,则使用当前 NumberFormatInfo 对象给定的默认货币精度。

D 或 d
十进制数
只有整型才支持此格式。数字转换为十进制数字 (0-9) 的字符串,如果数字为负,则前面加负号。

精度说明符指示结果字符串中所需的最少数字个数。如果需要的话,则用零填充该数字的左侧,以产生精度说明符给定的数字个数。

E 或 e
科学记数法(指数)
数字转换为“-d.ddd…E+ddd”或“-d.ddd…e+ddd”形式的字符串,其中每个“d”表示一个数字 (0-9)。如果该数字为负,则该字符串以减号开头。小数点前总有一个数字。

精度说明符指示小数点后所需的位数。如果省略精度说明符,则使用默认值,即小数点后六位数字。

格式说明符的大小写指示在指数前加前缀“E”还是“e”。指数总是由正号或负号以及最少三位数字组成。如果需要,用零填充指数以满足最少三位数字的要求。

F 或 f
定点
数字转换为“-ddd.ddd…”形式的字符串,其中每个“d”表示一个数字 (0-9)。如果该数字为负,则该字符串以减号开头。

精度说明符指示所需的小数位数。如果忽略精度说明符,则使用当前 NumberFormatInfo 对象给定的默认数值精度。

G 或 g
常规
根据数字类型以及是否存在精度说明符,数字会转换为定点或科学记数法的最紧凑形式。如果精度说明符被省略或为零,则数字的类型决定默认精度,如下表所示。

Byte 或 SByte:3

Int16 或 UInt16:5

Int32 或 UInt32:10

Int64 或 UInt64:19

Single:7

Double:15

Decimal:29

如果用科学记数法表示数字时指数大于 -5 而且小于精度说明符,则使用定点表示法;否则使用科学记数法。如果要求有小数点,并且忽略尾部零,则结果包含小数点。如果精度说明符存在,并且结果的有效数字位数超过指定精度,则通过舍入删除多余的尾部数字。

上述规则有一个例外:如果数字是 Decimal 而且省略精度说明符时。在这种情况下总使用定点表示法并保留尾部零。

使用科学记数法时,如果格式说明符是“G”,结果的指数带前缀“E”;如果格式说明符是“g”,结果的指数带前缀“e”。

N 或 n
数字
数字转换为“-d,ddd,ddd.ddd…”形式的字符串,其中“-”表示负数符号(如果需要),“d”表示数字 (0-9),“,”表示数字组之间的千位分隔符,“.”表示小数点符号。实际的负数模式、数字组大小、千位分隔符以及十进制分隔符由当前 NumberFormatInfo 对象指定。

精度说明符指示所需的小数位数。如果忽略精度说明符,则使用当前 NumberFormatInfo 对象给定的默认数值精度。

P 或 p
百分比
数字转换为由 NumberFormatInfo.PercentNegativePattern 或 NumberFormatInfo.PercentPositivePattern 属性定义的、表示百分比的字符串,前者用于数字为负的情况,后者用于数字为正的情况。已转换的数字乘以 100 以表示为百分比。

精度说明符指示所需的小数位数。如果忽略精度说明符,则使用当前 NumberFormatInfo 对象给定的默认数值精度。

R 或 r
往返过程
只有 Single 和 Double 类型支持此格式。往返过程说明符保证转换为字符串的数值再次被分析为相同的数值。使用此说明符格式化数值时,首先使用常规格式对其进行测试:Double 使用 15 位精度,Single 使用 7 位精度。如果此值被成功地分析回相同的数值,则使用常规格式说明符对其进行格式化。但是,如果此值未被成功地分析为相同数值,则它这样格式化:Double 使用 17 位精度,Single 使用 9 位精度。

虽然此处可以存在精度说明符,但它将被忽略。使用此说明符时,往返过程优先于精度。

X 或 x
十六进制数
只有整型才支持此格式。数字转换为十六进制数字的字符串。格式说明符的大小写指示对大于 9 的十六进制数字使用大写字符还是小写字符。例如,使用“X”产生“ABCDEF”,使用“x”产生“abcdef”。

精度说明符指示结果字符串中所需的最

Math.Round(3.45, 2, MidpointRounding.AwayFromZero);

C#中virtual与abstract的区别

C#的virtual & abstract经常让人混淆,这两个限定词都是为了让子类进行重新定义,覆盖父类的定义。但是用法上差别很大。

a)     virtual修饰的方法必须有方法实现(哪怕只有一对大括号),abstract修饰的方法不能有实现。

b)    virtual可以被子类重写,abstract必须被子类重写

c)     如果类中的某一函数被abstact修饰,则类名也必须用abstact修饰

d)    Abstract修饰的类不能被创建实例。

e)     C#中如果准备在子类重写父类的方法,则该方法在父类中必须用virtual修饰,在子类中必须用overide修饰,避免了程序员在子类中不小心重写了父类父类方法。