之前给一个大佬做有赞应用时候遇到了post收发的问题，其实实现起来很简单的。无奈网上关于这方面的资料很少，特此整理一下，希望帮助有需要的人_(:з」∠)_

发送

直接上代码了，关键的地方我加了注释，应该不难理解。

C#提供了相关的API，很方便。这段代码可以直接拿去用_(:з」∠)_

大致步骤就是创建Request-填充信息-发送。

/// <summary>
/// Post提交数据
/// </summary>
/// <param name="postUrl">URL</param>
/// <param name="paramData">参数</param>
/// <returns></returns>
string PostWebRequest(string postUrl, string paramData)
{
    string ret = string.Empty;
    try
    {
        byte[] byteArray = Encoding.UTF8.GetBytes(paramData);
        HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(new Uri(postUrl));
        // 提交方法，POST/GET等
        webReq.Method = "POST";
        // ContentType
        webReq.ContentType = "application/x-www-form-urlencoded";
        webReq.ContentLength = byteArray.Length;

        Stream newStream = webReq.GetRequestStream();
        //写入参数
        newStream.Write(byteArray, 0, byteArray.Length);
        newStream.Close();
        HttpWebResponse response = (HttpWebResponse)webReq.GetResponse();
        StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
        ret = sr.ReadToEnd();

        sr.Close();
        response.Close();
        newStream.Close();
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
    return ret;
}

接收

接收消息模块我分了两部分，一是主体，如何调用api进行监听。这部分需要另开一个线程来处理。

/// <summary>
/// 监听post消息，在收到消息后发送响应消息。
/// 建议使用死循环反复监听，且开启一个线程执行该方法。
/// </summary>
void ListenWebRequest()
{
    // string url= "需要监听的url范围";
    // 示例：(这里有个坑，见下文)
    string url = "http://127.0.0.1:2333";
    try
    {
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add(url);

        // 开始监听端口，接收客户端请求
        listener.Start();

        // 阻塞主函数至接收到一个客户端请求为止
        // 也可以使用listener.BeginGetContext()异步监听
        HttpListenerContext context = listener.GetContext();
        HttpListenerRequest request = context.Request;
        HttpListenerResponse response = context.Response;

        // msg即为body内容
        string msg = GetBodyString(request);

        // 通过QueryString索引获取post参数
        string sample = request.QueryString["sample"];

        // 收到信息后返回数据
        string responseString = "响应数据";
        response.StatusCode = 200;
        // header头信息
        response.Headers.Add("Access-Control-Allow-Origin", "*");
        // contentType 类型
        response.ContentType = "application/json";
        response.ContentEncoding = System.Text.Encoding.UTF8;
        byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
        response.ContentLength64 = buffer.Length;
        Stream output = response.OutputStream;
        output.Write(buffer, 0, buffer.Length);

        output.Close();
        listener.Stop();
        listener.Close();
    }
    catch (Exception ex)
    {
        // TODO
    }
}

第二部分，由于接收到的post消息中body内容是以流格式的，还需要将其转换为string。

/// <summary>
/// 将body内容解析为String。
/// </summary>
/// <returns>The body string.</returns>
/// <param name="request">Request.</param>
string GetBodyString(HttpListenerRequest request)
{
    string result = null;
    using (System.IO.Stream body = request.InputStream) // here we have data
    {
        using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
        {
            result = reader.ReadToEnd();
        }
    }

    if (string.IsNullOrEmpty(result))
    {
        // TODO 读取到空消息
    }
    else
    {
        // TODO 成功读取消息
    }

    return result;
}

推荐一个post测试工具

Restlet Client – REST API Testing

谷歌浏览器插件：下载链接（需要翻墙）

炒鸡好用！

碎碎念

就是在接收方法那绑定的url，我当时用的腾讯云的服务器（window系统）测试的。是这样的，

如果url是localhost或127.0.0.1，在服务器本机测试一切正常。但如果从外网向其post数据，会报400或405错误。

如果url是服务器外网IP呢，干脆直接抛异常，好像是无法绑定。

最后尝试了下将url改成内网IP，一切OK。不过我还是不知道是什么原因_(:з」∠)_

使用C#实现POST消息发送和读取最先出现在初晴神社。

例如将一个double数组的元素当做int类型输出，使用for循环可能需要这样写

for (int i = 0; i < doubleArray.Length; i++)
{
      Console.WriteLine((int)doubleArray[i]);
}

但如果使用foreach：

foreach (int i in doubleArray)
{
        Console.WriteLine(i);
}

/************************************************/

回到正题，foreach的原理是什么，或者说怎么实现一个可以被foreach遍历的结构呢？

答案主要在于两个C#接口，IEnumerable和IEnumerator。

IEnumerable 接口里有一个方法GetEnumerator。IEnumerable的意思是这个集合是可以遍历的，而GetEnumerator方法返回的IEnumerator的就是一个遍历器，用这个工具来遍历这个类。

IEnumorator接口中定义的内容包括Current，就是返回这个遍历工具所指向的那个容器的当前的元素，MoveNext ()方法就是指向下一个元素，当遍历到最后没有元素时，返回一个false.

上代码：School集合里有很多Student

首先定义一个Student类，这个类里有属性Name和构造器：

class Student
{
    public string Name { get; set; };

    public Student()
    {

    }

    public Student(string name)
    {
        Name = name;
    }
}

接下来定义School类，其中包含一个Student数组，构造方法。并继承IEnumerable接口并实现IEnumerator IEnumerable.GetEnumerator()方法：

class School : IEnumerable
{
    private Student[] students;

    public School(Student[] stus)
    {
        students = (Student[])stus.Clone();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return new PeopleEnum(students);
    }
}

其中PeopleEnum  是继承了IEnumerator接口的类型，用于foreach遍历。IEnumerator接口中包括了object IEnumerator.Current属性和public bool MoveNext()，public void Reset()方法。

如果使用了泛型T还会有T IEnumerator<T>.Current属性。

class PeopleEnum : IEnumerator
{
    private Student[] students;
    private int index = -1;

    object IEnumerator.Current => Current;
    public Student Current
    {
        get
        {
            return students[index];
        }
    }

    public PeopleEnum(Student[] stus)
    {
        students= stus;
    }

    public bool MoveNext()
    {
        index++;
        return index < students.Length;
    }

    public void Reset()
    {
        index = -1;
    }
}

我们额外添加了student数组和一个数组下标index。

其中foreach首先调用MoveNext()  方法，使其下标加1，判断是否越界。如果没有越界就通过Current取出目标值。可以看到如果没有使用泛型的话，返回的是object类型的值，这也是为什么foreach不需要我们进行强制类型转换的原因，即foreach会自动进行转换，缺点就是涉及到装箱拆箱，影响效率。但是这一点可以通过使用泛型避免，有点类似于C#中的ArrayList和List。

C#中的foreach实现原理最先出现在初晴神社。

原则1：尽可能地使用属性，而不是可直接访问的数据成员

• 属性(property)一直是C#语言中比较有特点的存在。属性允许将数据成员作为共有接口的一部分暴露出去，同时仍旧提供面向对象环境下所需的封装。属性这个语言元素可以让你像访问数据成员一样使用，但其底层依旧是使用方法实现的。
• 使用属性，可以非常轻松的在get和set代码段中加入检查机制。
• 需要注意，正因为属性是用方法实现的，所以它拥有方法所拥有的一切语言特性：

• • 1）属性增加多线程的支持是非常方便的。你可以加强 get 和 set 访问器（accessors）的实现来提供数据访问的同步。
  • 2）属性可以被定义为virtual。
  • 3）可以把属性扩展为abstract。
  • 4）可以使用泛型版本的属性类型。
  • 5）属性也可以定义为接口。
  • 6）因为实现实现访问的方法get与set是独立的两个方法，在C# 2.0之后，你可以给它们定义不同的访问权限，来更好的控制类成员的可见性。
  • 7）而为了和多维数组保持一致，我们可以创建多维索引器，在不同的维度上使用相同或不同类型。
• 无论何时，需要在类型的公有或保护接口中暴露数据，都应该使用属性。如果可以也应该使用索引器来暴露序列或字典。现在多投入一点时间使用属性，换来的是今后维护时的更加游刃有余。

 原则2：偏向于使用运行时常量而不是编译时常量

• 编译时常量（const）的值会被目标代码中的值直接取代。
• 运行时常量（readonly）的值是在运行时进行求值。引用运行时生成的IL将引用到readonly变量，而不是变量的值。

• 编译时常量（const）仅能用于数值和字符串。
• 运行时常量（readonly）可以为任意类型。运行时常量必须在构造函数或初始化器中初始化，因为在构造函数执行后不能再被修改。你可以让某个readonly值为一个DataTime结构，而不能指定某个const为DataTIme。
• 可以用readonly值保存实例常量，为类的每个实例存放不同的值。而编译时常量就是静态的常量。
• 有时候你需要让某个值在编译时才确定，就最好是使用运行时常量（readonly）。
• 标记版本号的值就应该使用运行时常量，因为它的值会随着每个不同版本的发布而改变。
• const优于readonly的地方仅仅是性能，使用已知的常量值要比访问readonly值略高一点，不过这其中的效率提升，可以说是微乎其微的。

原则3： 推荐使用is 或as操作符而不是强制类型转换

• C#中，is和as操作符的用法概括如下。

• • is : 检查一个对象是否兼容于其他指定的类型,并返回一个Bool值,永远不会抛出异常。
  • as：作用与强制类型转换是一样,但是永远不会抛出异常,即如果转换不成功,会返回null。
• 尽可能的使用as操作符，因为相对于强制类型转换来说，as更加安全，也更加高效。
• as在转换失败时会返回null，在转换对象是null时也会返回null，所以使用as进行转换时，只需检查返回的引用是否为null即可。
• as和is操作符都不会执行任何用户自定义的转换，它们仅当运行时类型符合目标类型时才能转换成功，也不会在转换时创建新的对象。
• as运算符对值类型是无效，此时可以使用is，配合强制类型转换进行转换。
• 仅当不能使用as进行转换时，才应该使用is操作符。否则is就是多余的。

原则4： 推荐使用条件属性而不是#if条件编译

• 由于#if/#endif很容易被滥用，使得编写的代码难于理解且更难于调试。C#为此提供了一条件特性(Conditional attribute)。使用条件特性可以将函数拆分出来，让其只有在定义了某些环境变量或设置了某个值之后才能编译并成为类的一部分。Conditional特性最常用的地方就是将一段代码变成调试语句。
• Conditional特性只可应用在整个方法上，另外，任何一个使用Conditional特性的方法都只能返回void类型。不能再方法内的代码块上应用Conditional特性。也不可以在有返回值的方法上应用Conditional特性。但应用了Conditional特性的方法可以接受任意数目的引用类型参数。
• 使用Conditional特性生成的IL要比使用#if/#Eendif时更有效率。同时，将其限制在函数层面上可以更加清晰地将条件性的代码分离出来，以便进一步保证代码的良好结构。

原则5：理解几个等同性判断之间的关系

• C#中可以创建两种类型：值类型和引用类型。如果两个引用类型的变量指向的是同一个对象，它们将被认为是“引用相等”。如果两个值类型的变量类型相同，而且包含同样的内容，它们被认为是“值相等”。这也是等同性判断需要如此多方法的原因。
• 当我们创建自己的类型时（无论是类还是struct），应为类型定义“等同性”的含义。C#提供了4种不同的函数来判断两个对象是否“相等”。

• • public static bool ReferenceEquals (object left, object right);判断两个不同变量的对象标识（object identity）是否相等。无论比较的是引用类型还是值类型，该方法判断的依据都是对象标识，而不是对象内容。
  • public static bool Equals (object left, object right); 用于判断两个变量的运行时类型是否相等。
  • public virtual bool Equals(object right); 用于重载
  • public static bool operator ==(MyClass left, MyClass right); 用于重载
• 不应该覆写Object.referenceEquals（）静态方法和Object.Equals（）静态方法，因为它们已经完美的完成了所需要完成的工作，提供了正确的判断，并且该判断与运行时的具体类型无关。对于值类型，我们应该总是覆写Object.Equals（）实例方法和operatior==( ),以便为其提供效率更高的等同性判断。对于引用类型，仅当你认为相等的含义并非是对象标识相等时，才需要覆写Object.Equals( )实例方法。在覆写Equals( )时也要实现IEquatable。
• PS: 此原则对应于《EffectiveC# Second Edition》中原则6。

原则6：了解GetHashCode( )的一些坑

• GetHashCode( )方法在使用时会有不少坑，要谨慎使用。GetHashCode()函数仅会在一个地方用到，即为基于散列(hash)的集合定义键的散列值时，此类集合包括HashSet和Dictionary容器等。对引用类型来讲，索然可以正常工作，但是效率很低。对值类型来讲，基类中的实现有时甚至不正确。而且，编写的自己GetHashCode( )也不可能既有效率又正确。
• 在.NET中，每个对象都有一个散列码，其值由System.Object.GetHashCode()决定。
• 实现自己的GetHashCode( )时，要遵循上述三条原则：

• • 如果两个对象相等（由operation==定义），那么他们必须生成相同的散列码。否则，这样的散列码将无法用来查找容器中的对象。
  • 对于任何一个对象A，A.GetHashCode()必须保持不变。
  • 对于所有的输入，散列函数应该在所有整数中按随机分别生成散列码。这样散列容器才能得到足够的效率提升。
• PS: 此原则对应于《EffectiveC# Second Edition》中原则7。

原则7：理解短小方法的优势

• 将C#代码翻译成可执行的机器码需要两个步骤。C#编译器将生成IL，并放在程序集中。随后，JIT将根据需要逐一为方法（或是一组方法，如果涉及内联）生成机器码。短小的方法让JIT编译器能够更好地平摊编译的代价。短小的方法也更适合内联。
• 除了短小之外，简化控制流程也很重要。控制分支越少，JIT编译器也会越容易地找到最适合放在寄存器中的变量。
• 所以，短小方法的优势，并不仅体现在代码的可读性上，还关系到程序运行时的效率。
• 此原则对应于《EffectiveC# Second Edition》中原则11。

原则8：选择变量初始化而不是赋值语句

• 成员初始化器是保证类型中成员均被初始化的最简单的方法——无论调用的是哪一个构造函数。初始化器将在所有构造函数执行之前执行。使用这种语法也就保证了你不会再添加的新的构造函数时遗漏掉重要的初始化代码。
• 综上，若是所有的构造函数都要将某个成员变量初始化成同一个值，那么应该使用初始化器。
• PS: 此原则对应于《Effective C# Second Edition》中原则12。

原则9：正确地初始化静态成员变量

• C#提供了有静态初始化器和静态构造函数来专门用于静态成员变量的初始化。
• 静态构造函数是一个特殊的函数，将在其他所有方法执行之前以及变量或属性被第一次访问之前执行。可以用这个函数来初始化静态变量，实现单例模式或执行类可用之前必须进行的任何操作。
• 和实例初始化一样，也可以使用初始化器语法来替代静态的构造函数。若只是需要为某个静态成员分配空间，那么不妨使用初始化器的语法。而若是要更复杂一些的逻辑来初始化静态成员变量，那么可以使用静态构造函数。
• 使用静态构造函数而不是静态初始化器最常见的理由就是处理异常。在使用静态初始化器时，我们无法自己捕获异常。而在静态构造函数中却可以做到。
• PS: 此原则对应于《Effective C# Second Edition》中原则13。

原则10：使用构造函数链（减少重复的初始化逻辑）

• 编写构造函数很多时候是个重复性的劳动，如果你发现多个构造函数包含相同的逻辑，可以将这个逻辑提取到一个通用的构造函数中。这样既可以避免代码重复，也可以利用构造函数初始化器来生成更高效的目标代码。
• C#编译器将把构造函数初始化器看做是一种特殊的语法，并移除掉重复的变量初始化器以及重复的基类构造函数调用。这样使得最终的对象可以执行最少的代码来保证初始化的正确性。
• 构造函数初始化器允许一个构造函数去调用另一个构造函数。而C# 4.0添加了对默认参数的支持，这个功能也可以用来减少构造函数中的重复代码。你可以将某个类的所有构造函数统一成一个，并为所有的可选参数指定默认值。其他的几个构造函数调用某个构造函数，并提供不同的参数即可。
• PS: 此原则对应于《EffectiveC# Second Edition》中原则14。

原则11：实现标准的销毁模式

• GC可以高效地管理应用程序使用的内存。不过创建和销毁堆上的对象仍旧需要时间。若是在某个方法中创建了太多的引用对象，将会对程序的性能产生严重的影响。
• 这里有一些规则，可以帮你尽量降低GC的工作量：

• • 1）若某个引用类型（值类型无所谓）的局部变量用于被频繁调用的例程中，那么应该将其提升为成员变量。
  • 2）为常用的类型实例提供静态对象。
  • 3）创建不可变类型的最终值。比如string类的+=操作符会创建一个新的字符串对象并返回，多次使用会产生大量垃圾，不推荐使用。对于简单的字符串操作，推荐使用string.Format。对于复杂的字符串操作，推荐使用StringBuilder类。

• PS: 此原则对应于《EffectiveC# Second Edition》中原则16

原则12：区分值类型和引用类型

• C#中，class对应引用类型，struct对应值类型。
• C#不是C++，不能将所有类型定义成值类型并在需要时对其创建引用。C#也不是Java，不像Java中那样所有的东西都是引用类型。你必须在创建时就决定类型的表现行为，这相当重要，因为稍后的更改可能带来很多灾难性的问题。
• 值类型无法实现多态，因此其最佳用途就是存放数据。引用类型支持多态，因此用来定义应用程序的行为。
• 一般情况下，我们习惯用class，随意创建的大都是引用类型，若下面几点都肯定，那么应该创建struct值类型：

• • 1）该类型主要职责在于数据存储吗？
  • 2）该类型的公有接口都是由访问其数据成员的属性定义的吗？
  • 3）你确定该类型绝不会有派生类型吗？
  • 4）你确定该类型永远都不需要多态支持吗？

• 用值类型表示底层存储数据的类型，用引用类型来封装程序的行为。这样，你可以保证类暴露出的数据能以复制的形式安全提供，也能得到基于栈存储和使用内联方式存储带来的内存性能提升，更可以使用标准的面向对象技术来表达应用程序的逻辑。而倘若你对类型未来的用图不确定，那么应该选择引用类型。
• PS: 此原则对应于《Effective C# Second Edition》中原则18。

原则13：保证0为值类型的有效状态

• 在创建自定义枚举值时，请确保0是一个有效的选项。若你定义的是标志(flag)，那么可以将0定义为没有选中任何状态的标志（比如None）。即作为标记使用的枚举值（即添加了Flags特性）应该总是将None设置为0。
• PS: 此原则对应于《Effective C# Second Edition》中原则19。

原则14：保证值类型的常量性和原子性

• 常量性的类型使得我们的代码更加易于维护。不要盲目地为类型中的每一个属性都创建get和set访问器。对于那些目的是存储数据的类型，应该尽可能地保证其常量性和原子性。
• PS: 此原则对应于《Effective C# Second Edition》中原则20。

原则15：限制类型的可见性

• 在保证类型可以完成其工作的前提下。你应该尽可能地给类型分配最小的可见性。也就是，仅仅暴露那些需要暴露的。尽量使用较低可见性的类来实现公有接口。可见性越低，能访问你功能的代码越少，以后可能出现的修改也就越少。
• PS: 此原则对应于《Effective C# Second Edition》中原则21。

原则16：通过定义并实现接口替代继承

• 理解抽象基类（abstract class）和接口（interface）的区别：

• • 接口是一种契约式的设计方式，一个实现某个接口的类型，必须实现接口中约定的方法。抽象基类则为一组相关的类型提供了一个共同的抽象。也就是说抽象基类描述了对象是什么，而接口描述了对象将如何表现其行为。
  • 接口不能包含实现，也不能包含任何具体的数据成员。而抽象基类可以为派生类提供一些具体的实现。
  • 基类描述并实现了一组相关类型间共用的行为。接口则定义了一组具有原子性的功能，供其他不相关的具体类型来实现。

• 理解好两者之间的差别，我们便可以创造更富表现力、更能应对变化的设计。使用类层次来定义相关的类型。用接口暴露功能，并让不同的类型实现这些接口。
• PS: 此原则对应于《EffectiveC# Second Edition》中原则22。

原则17：理解接口方法和虚方法的区别

• 第一眼看来，实现接口和覆写虚方法似乎没有什么区别，实际上，实现接口和覆写虚方法之间的差别很大。

• • 接口中声明的成员方法默认情况下并非虚方法，所以，派生类不能覆写基类中实现的非虚接口成员。若要覆写的话，将接口方法声明为virtual即可。
  • 基类可以为接口中的方法提供默认的实现，随后，派生类也可以声明其实现了该接口，并从基类中继承该实现。
  • 实现接口拥有的选择要比创建和覆写虚方法多。我们可以为类层次创建密封（sealed）的实现，虚实现或者抽象的契约。还可以创建密封的实现，并在实现接口的方法中提供虚方法进行调用。

• PS: 此原则对应于《EffectiveC# Second Edition》中原则23。

原则18：用委托实现回调

• 在C#中，回调是用委托来实现的，主要要点如下：

• • 委托为我们提供了类型安全的回调定义。虽然大多数常见的委托应用都和事件有关，但这并不是C#委托应用的全部场合。当类之间有通信的需要，并且我们期望一种比接口所提供的更为松散的耦合机制时，委托便是最佳的选择。
  • 委托允许我们在运行时配置目标并通知多个客户对象。委托对象中包含一个方法的应用，该方法可以是静态方法，也可以是实例方法。也就是说，使用委托，我们可以和一个或多个在运行时联系起来的客户对象进行通信。
  • 由于回调和委托在C#中非常常用，以至于C#特地以lambda表达式的形式为其提供了精简语法。
  • 由于一些历史原因，.NET中的委托都是多播委托（multicast delegate）。多播委托调用过程中，每个目标会被依次调用。委托对象本身不会捕捉任何异常。因此，任何目标抛出的异常都会结束委托链的调用。

• PS: 此原则对应于《EffectiveC# Second Edition》中原则24。

原则19：用事件模式实现通知

• 事件提供了一种标准的机制来通知监听者，而C#中的事件其实就是观察者模式的一个语法上的快捷实现。
• 事件是一种内建的委托，用来为事件处理函数提供类型安全的方法签名。任意数量的客户对象都可以将自己的处理函数注册到事件上，然后处理这些事件，这些客户对象无需在编译器就给出，事件也不必非要有订阅者才能正常工作。
• 在C#中使用事件可以降低发送者和可能的通知接受者之间的耦合，发送者可以完全独立于接受者进行开发。
• PS: 此原则对应于《EffectiveC# Second Edition》中原则25。

原则20：避免返回对内部类对象的引用

• 若将引用类型通过公有接口暴露给外界，那么对象的使用者即可绕过我们定义的方法和属性来更改对象的内部结构，这会导致常见的错误。
• 共有四种不同的策略可以防止类型内部的数据结构遭到有意或无意的修改：

• • 1）值类型。当客户代码通过属性来访问值类型成员时，实际返回的是值类型的对象副本。
  • 2）常量类型。如System.String。
  • 3）定义接口。将客户对内部数据成员的访问限制在一部分功能中。
  • 4）包装器（wrapper）。提供一个包装器，仅暴露该包装器，从而限制对其中对象的访问。

• PS: 此原则对应于《Effective C# Second Edition》中原则26。

原则21：仅用new修饰符处理基类更新

• 使用new操作符修饰类成员可以重新定义继承自基类的非虚成员。
• new修饰符只是用来解决升级基类所造成的基类方法和派生类方法冲突的问题。
• new操作符必须小心使用。若随心所欲的滥用，会造成对象调用方法的二义性。
• PS: 此原则对应于《Effective C# Second Edition》中原则33。

原则22：尽量减少在公有API中使用动态对象

• 动态对象有一些“强制性”，即所有打交道的对象都变成动态的。若是某个操作的某个参数是动态的，那么其结果也会是动态的。若是每个方法返回了一个动态对象，那么所有使用过该对象的地方也变成了动态对象。
• 所以，若你要在程序中使用动态特性，请尽量不要在公有接口中使用，这样可以将动态类型现在在一个单独的对象或类型中。
• 应该将动态对象限制在最需要的地方，然后立即将动态对象转换为静态类型。当你的代码依赖于其他环境中创建的动态类型时，可以用专门的静态类型封装这些动态对象，并提供静态的公有接口。
• PS: 此原则对应于《Effective C# Second Edition》中原则44。

【转】【《Effective C#》提炼总结】提高Unity中C#代码质量的22条准则最先出现在初晴神社。

可是如果元素类型没有实现IComparable<T>，或者默认的比较逻辑不符合要求，又该怎么办呢？

为了指定非默认的排序顺序，可以调用List<T>.Sort()的重载版本，它获取一个IComparer<T>作为实参。

首先我们需要了解一下IComparable<T>和IComparer<T>的区别：

IComparable<T>：“我知道如何将我自己和我的类型的另一个实例进行比较”；

IComparer<T>：“我知道如何比较给定类型的两个实例”；

很明显，IComparable<T>由需要排序的对象继承并实现，IComparer<T>需要另建一个类继承并实现；

来看下面这个例子：

首先新建一个需要排序的类Name：

class Name
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }

    public Name(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public override string ToString()
    {
        return String.Format($"{FirstName} {LastName}");
    }
}

然后新建一个比较类，继承并实现IComparer<T>接口：

class NameComparison : IComparer<Name>
{
    public int Compare(Name x, Name y)
    {
        if (Object.ReferenceEquals(x, y))
            return 0;
        if (x == null)
            return 1;
        if (y == null)
            return -1;

        int result = StringCompare(x.FirstName, y.FirstName);
        if (result == 0)
        {
            result = StringCompare(x.LastName, y.LastName);
        }

        return result;
    }

    public static int StringCompare(string x, string y)
    {
        if (Object.ReferenceEquals(x, y))
            return 0;
        if (x == null)
            return 1;
        if (y == null)
            return -1;

        return x.CompareTo(y);
    }
}

接下来在Main方法中调用：

class Program
{
    static void Main(string[] args)
    {
        List<Name> nameList = new List<Name>()
            {
                new Name("Michelle", "Green"),
                new Name("Susan", "Miller"),
                new Name("Susan",""),
                new Name("","Smith"),
                new Name("Keisey","Smith")
            };

        nameList.Sort(new NameComparison());

        foreach (Name item in nameList)
        {
            Console.WriteLine(item);
        }
    }
}

这样就能得到输出结果：

注意：实现IComparable<T>和IComparer<T>时必须生成一个全序。

CompareTo的实现必须为任何可能的数据排列组合提供完全一致的排序结果。

例如上述代码中考虑到了实参为null的情况。不能“任何一个元素为null就返回0,”，否则两个元素可能等于null，但相互不等，程序可能会崩溃！

C#中自定义集合排序最先出现在初晴神社。

委托是具有相同签名的函数(方法)的类型，事件是委托的应用方式之一。

委托相当于一个对方法的引用，可以将方法当做参数来传递，而事件相当于特殊的委托。

声明事件（Event）

在类的内部声明事件，首先必须声明该事件的委托类型。例如：

public delegate void MyDelegateHandler();

然后，声明事件本身，使用 event 关键字：

// 基于上面的委托定义事件
public event MyDelegateHandler MyDelegate;

区别/event的作用

而event规范化了只能用+=和-=，或者在包含类内使用=；

高级用法/C#中对事件是如何处理

C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。

就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
1．定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2．定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
3．定义”事件处理方法，它应当与delegate对象具有相同的参数和返回值类型”。
4．用event关键字定义事件对象，它同时也是一个delegate对象。
5．用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6．在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7． 在适当的地方调用事件触发方法触发事件。

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 事件
{
    class EventTest
    {
        // 步骤1，定义delegate对象
        private delegate void EventHandler<TEventArgs>(object sender, TEventArgs e)
            where TEventArgs : EventArgs;

        // 步骤4，用event关键字定义事件对象
        private EventHandler myEvent;

        // 步骤2（定义事件参数类）
        public class TestEventArgs : EventArgs
        {
            public string args1 = "这是参数1";
            public string args2 = "这是参数2";
        }

        public EventTest()
        {
            // 步骤5，用+=操作符将事件添加到队列中
            myEvent += HandleFunc;
        }

        // 步骤3，定义事件处理方法，它与delegate对象具有相同的参数和返回值类型
        public void HandleFunc(object sender, EventArgs e)
        {
            Console.WriteLine("调用者:" + sender.ToString());
            TestEventArgs testEventArgs = e as TestEventArgs;
            Console.WriteLine(testEventArgs.args1);
            Console.WriteLine(testEventArgs.args2);
        }

        public void InvokeTest()
        {
            // 步骤6，触发事件
            myEvent(this, new TestEventArgs());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            EventTest eventTest = new EventTest();
            eventTest.InvokeTest();
        }
    }
}

再来一个栗子：

主人养了一条忠实的看门狗，晚上主人睡觉的时候，狗负责看守房子。一旦有小偷进来，狗就发出一个Alarm事件，主人接到Alarm事件后就会采取相应的行动。

//事件发送者

class Dog
{
    //1.声明关于事件的委托；
    public delegate void AlarmEventHandler(object sender, EventArgs e);

    //2.声明事件；   
    public event AlarmEventHandler Alarm;

    //3.编写引发事件的函数；
    public void OnAlarm()
    {
        if (this.Alarm != null)
        {
            Console.WriteLine("/n狗报警: 有小偷进来了,汪汪~~~~~~~");
            this.Alarm(this, new EventArgs());   //发出警报
         }
    }
}

//事件接收者
class Host
{
    //４.编写事件处理程序
    void HostHandleAlarm(object sender, EventArgs e)
    {
        Console.WriteLine("主  人: 抓住了小偷！");
    }

    //５.注册事件处理程序
    public Host(Dog dog)
    {
        dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);
    }
}

//６.现在来触发事件
class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog();
        Host host = new Host(dog);

        //当前时间，从2008年12月31日23:59:50开始计时
        DateTime now = new DateTime(2008, 12, 31, 23, 59, 50);
        DateTime midnight = new DateTime(2009, 1, 1, 0, 0, 0);

        //等待午夜的到来
        Console.WriteLine("时间一秒一秒地流逝... ");
        while (now < midnight)
        {
            Console.WriteLine("当前时间: " + now);
            System.Threading.Thread.Sleep(1000);   //程序暂停一秒
            now = now.AddSeconds(1);                //时间增加一秒
         }

        //午夜零点小偷到达,看门狗引发Alarm事件
        Console.WriteLine("/n月黑风高的午夜: " + now);
        Console.WriteLine("小偷悄悄地摸进了主人的屋内... ");
        dog.OnAlarm();
    }
} 

当午夜时分小偷到达时，dog调用dog.OnAlarm()函数，从而触发Alarm事件，于是”系统”找到并执行了注册在Alarm事件中的事件处理程序HostHandleAlarm()。

事件处理委托习惯上以EventHandler结尾，比如AlarmEventHandler。事件Alarm实际上是事件处理委托AlarmEventHandler的一个实例。引发事件的代码常常被编写成一个函数，.NET约定这种函数的名称为“OnEventName”，比如OnAlarm()的函数。在Host类中，我们定义了事件处理程序HostHandleAlarm()，并把它注册到dog.Alarm事件中。

事件处理程序的参数应该和事件委托相同。一般情况下，事件处理程序接受两个参数，一个是事件的发送者sender，一个是事件参数e。事件参数用于在发送者和接收者之间传递信息。

最近通过练习多少发现了些和大角虫差距的地方，

举个栗子，

根据传递进来参数的不同来选择不同的处理方式

像我这种鶸可能首先想到的就是if-else

而dalao可能会选用委托的方式

咋一看虽然用if-else也能解决问题

但是差距就体现在这

dalao的做法效率会更高

自己一看，

原来如此，斯国一~

自己想不到用更高级的方法去解决问题

这才是自己需要进步的地方

_(:з」∠)_

C#中的委托与事件最先出现在初晴神社。

readonly只能用于字段；

2.const只能为静态字段；而且不能显式声明为static，否则会报错；

readonly既可以是实例字段，也可以是静态字段；

3.const字段在所有实例中的值都相同；

readonly字段在不同实例里可以有不同的值；

4.const字段和变量只能在编译时赋值；

readonly可以在编译时和运行时（构造器或声明）赋值；

5.const无法用于数组，除非将数组初始化为null；

readonly用于数组时不会冻结数组内容，而是冻结数组实例，包括元素个数；

数组是引用类型，而const要求提供一个编译器常量，引用类型的编译器常量只有null；

如果需要数组元素也不可变，可以使用 ReadOnlyCollection 类型；

C#中const与readonly的区别最先出现在初晴神社。

这次目的为查漏补缺，选取的书目为《C# 6.0 本质论》，并对以前不了解的细节做了个记录_(:з」∠)_

所以这篇文章不会包含基础的C#知识，另外C#版本为6.0 _(:з」∠)_

一、C#概述

1.C#编译器允许为C#源代码文件使用任何文件扩展名，但一般使用”.cs”；

2.在C#关键字前添加“@”字符前缀可作为标志符使用；

3.

static void Main( string [ ] args )

args数组的第一个元素不是可执行文件名，而是之后第一个参数（区别于C++）

要想获取完整命令可以使用 System.Environment.CommanLine；

4.字符串插值：

$"{ 变量名 } , { 变量名 }"

5.如果想省略Console.WriteLine() 的Console，

可以在文件开始使用

using static System.Console;

注：using static 只对静态方法和属性有效，对实例成员不起作用；

二、数据类型

6.var的目的是为了支持匿名类型，一般情况尽量不用；

7.值类型与引用类型本质区别：

值类型：数据类型总是值复制；

引用类型：数据类型总是引用复制；

8.堆：引用类型指向的内存区域；

9.可空修饰符”?” 将null赋值给值类型，在数据库编程中尤为有用；

10.多维数组：Length 为元素总数

int [ , ] cells;  

交错数组：Length 为外部数组的元素数

int [ ][ ] cells;

11.数组的Clear()方法将数组的每个元素都设为默认值；

12.数组的BinarySearch()方法（二分查找）使用前要对数组进行排序（ Array.Sort() ）；

13.要获取数组的特定维的长度使用

GetLength( int 维度 );

14.使用Clone()创建数组的全新副本；

15如何讲一个字符串反转：

（1）使用String.ToCharArray()转换为字符数组；

（2）使用Array.Reverse() 反转数组；

三、操作符和控制流

16.使用圆括号增加代码易读性；

17.不同于C++，C#中操作数总是从左到右求值；

18.当必须本地化时，要用组合格式而不是加法操作符来拼接字符串；

例如使用String.Format()而不是“字符串”+“字符串”

19.避免将二进制浮点类型用于相等性条件；

20.C#中0/0f得到NaN；

1/0f等于无穷；

21.空格解释操作符 ??

expression1 ?? expression2

还可以连接使用 x ?? y ?? z …

22.null条件操作符 ?   （有点复杂，具体用法百度搜索）

例如：

string args[ ];

if( args?.Length == 0 )

...

即

( args != null ) ? ( int? ) args.Length : null ;

23.round-trip格式说明符返回的字符串转换为数值肯定能获得原始值；

String.Format( "{ 0 : R } ",1.1234679... );

24.C#中转换进制

Convert.ToString(value, 进制数);

25.C#不允许从一个switch小节自然贯穿到下一个switch小节；

（可使用goto语句实现）

26.预处理指令的作用

（1）最常用的就是控制何时以及如何包含代码的指令；

（2）处理不同平台的差异；

（3）用于调试，例如#if DEBUG；

四、方法参数

27.在方法中尽可能地确定单一的推出位置；

28.表达式主题方法适用于单行可表示的方法；

29.String和string类型在CIL中无区别；

30.using：可以省略类型名之前的命名空间部分；

31.using static ：允许省略规定类型的任何成员之前的命名空间和类型名称；

32.一系列的方法调用时会创建“调用栈”；

33.ref参数只是传递变量的别名；

即：只是为现有的变量分配了参数名，而不是创建新变量并将实参的值复制给它；

用作ref参数的变量必须在传给被调用的方法之前赋值，因为被调用的方法可能冲这个变量中读取值；

34.out参数在功能上与ref参数完全一致；

区别：每个正常返回的代码路径都必须对所有的out参数进行赋值；

out参数在调用之前不需要赋值；

35.如果方法一定要返回多个值，考虑使用元组类型；

36.参数数组在希望参数数量可变时使用；

例如：

static string Combine ( params string[ ] paths )

要求：

（1）在方法声明的最后一个参数之前添加params关键字；

（2）将最后一个参数声明为数组，方法最多只能有一个参数数组；

37.可选参数一定放在所有必须的参数后面，另外默认值必须是常量；

38.考虑到命名参数，要将参数名视为API的一部分，尽量避免更改参数名；

39.编译器只使用调用者显式标识的参数，忽略调用者没有指定的所有可选参数；

即无可选参数的方法优先于有可选参数的；

40.编译器优先选择拥有最具体参数类型的方法；

41.所有的异常都是System.Exception类型；

42.catch快必须按照从具体最大具体排列；

43.finally块最适合用来执行资源清理；

44.避免捕获无法获知其正确行动的异常，对这种异常不进行处理比处理的不正确要好；

45.手动引发异常 throw new 异常类型(“…”)

46.throw; 保持了异常中的调用栈信息；

throw exception; 讲那些信息替换为当前信息；

调试时一般需要知道原始调用栈；

47.有事catch块能捕获到异常，但不能正确或完整处理，可以让这个catch块重新引发异常 throw;

48.要通过异常来指明错误；

不要通过它们作为返回值来指明错误；

49.避免使用异常处理来处理预料之中的情况；

异常是为了跟踪例外的，事先没有意料到的，而且可能造成严重后果的情况而设计的；

50.可以使用 TryParse() 代替 Parse() ，而非异常；

51.通常开发者必须假定用户会发生非预期的行为，应当防御性的编写代码，提前为所有能想到的“愚蠢的”用户行为拟定对策；

五、类

52.在C#中应该将new的作用理解为实例化对象，而不是分配内存；

53.可以像初始化字段那样初始化属性；

public string Salary { get; set; } = "Not enough";

54.属性和方法的选择

（1）方法用于代表行动，属性用于代表数据；

（2）属性倾向于对简单的计算提供简单的访问；

（3）调用属性的代价不应比访问字段高出太多；

55.如果没有额外的实现逻辑，要优先使用自动实现的属性；

56.要一直实现属性，不要直接调用字段；

57.属性和方法调用不允许作为ref和out参数使用；

原因：ref和out参数值在内部是实现时，需要将内存地址传给目标方法，但是属性不可能传送存储地址；

58.new操作符的细节

（1）new获取“空白内存”调用构造器；

（2）构造器初始化该内存；

（3）结束后，new返回内存引用；

59.this关键字在静态方法中无效；

60.静态构造器在首次访问类时自动调用；

不能显示调用，所以不允许任何参数；

61.考虑以内联方式初始化静态字段；

62.静态类在编译时会被标注为abstract和sealed，表明不能派生；

63.常量字段自动成静态字段，但是将常量字段显式声明为static会报错；

64.与const不同，readonly只能用于字段，不能用于局部变量；

65.和const字段不一样，每个实例的readonly字段都可以不同；

66.readonly字段既可以是实例字段，也可以是静态字段；

67.可以在执行时为readonly赋值，而非只能在编译时赋值，

const只能在编译时赋值；

68.将readonly应用于数组不会冻结数组的内容，而是冻结数组实例，包括个数；

69.要优先使用只读的自动实现的属性，而不是定义只读字段；

70.const无法用于数组，除非将数组初始化为null；

readonly可以；

原因：数组是引用类型，而const要求提供一个编译期常量，引用类型的编译器常量只有null；

71.如果需要数组元素也不可变，可以使用ReadOnlyCollection类型；

六、继承

72.扩展方法从技术上说不是类型的成员，所以不可继承，但可在派生类中使用；

73.在极少数需要多继承结构的时候，一般的解决方案是使用集合，即一个类包含另一个类的实例；

74.基类除构造器和析构器之外的所有成员都会在派生类中继承；

75.C#支持重写实例方法和属性，但不支持重写字段和任何静态成员；

76.对成员进行重载会造成“运行时”调用最深或者说派生的最远的实现

77.不要在构造器中调用会影响所构造对象的任何虚方法，因为有以下设计原则：

“总是调用派生的最远的虚成员，即使派生的构造器尚未完全执行完毕；”

（这与C++恰好相反）

78.new修饰符在基类面前隐藏了派生类重新声明的成员；

79.就CIL来说，new修饰符对编译器生成的代码没有任何影响；

从C#的角度看，它唯一的作用就是移除编译器警告；

80.多态性是指同一个签名可以有多个实现；

81.is操作符不仅检查转型是否成功，还会检查底层对象本身是否真的是目标对象；

七、接口

82.命名空间内只能包含public或internal的类定义，结构定义，接口定义等，如果没有指定，默认是internal；

protected表明存取限制于包含此定义的类或继承类命名空间是不继承的，所以protected用于命名空间的定义是无意义的，而protected可以用于嵌套类；

83.接口成员不能使用访问修饰符，默认都是public；

84.接口除了包含方法外还可以包含属性，索引器，事件；

85.接口基本上不具备继承的任何具体特点；

它仅仅承诺了能够调用的方法；

86.接口可以用于支持回调，

而继承不具备这个特点；

87.抽象类实现的具体方法为虚方法；

88.好的接口定义应该是具有专一性的，而不是多功能的，如果一个类只是实现了这个接口中的一个功能，而不得不去实现接口中的其他方法，就叫接口污染；

89.应当避免使用继承来实现组建功能，

而是使用黑箱复用，即对象组合；

90.如果抽象类实现接口，则可以把接口中的方法映射到抽象类中作为抽象方法而不必实现；

在抽象类子类中实现接口中方法；

91.抽象类主要应用于关系密切的对象；

接口适合为不相关的类提供通用功能；

92.显式接口和隐式接口的区别：

（1）显式接口中的方法没有修饰符；

隐式接口方法修饰符为public；

（2）显式接口中的方法可以看到从哪里来（通过接口访问，避免访问歧义），来源清晰，隐式接口看不出来源；

（3）显式接口会吧父级接口中的方法和属性完全继承；

隐式接口会过滤冗余的方法（多个接口有重名的方法）

93.避免显式是实现接口成员，除非有很好的理由，

但如果不确定成员的用途，就先选择显式实现；

八，值类型

94.结构属于值类型；

95.要创建不可变的值类型；

96.除了属性和字段，结构还可以包括方法和构造器；

结构不允许包含用户定义的默认（无参）构造器；

在没有提供默认构造器时，C#编译器自动生成一个默认构造器将所有字段初始化为各自的默认值；

97.C#禁止结构中的字段初始化器；

98.结构的构造方法中的所有显式声明的字段都必须初始化；

99.对于结构中的字段应该优先使用只读的自动实现的属性；

100.结构不支持终结器；

101.所有的值类型都有自动定义的无参构造器将值类型的实例初始化成默认状态；

102.除了枚举之外所有的值类型都派生自System.ValueType；

枚举继承自System.Enum，System.Enum继承自System.ValueType；

103.不允许在lock语句中使用值类型；

104.避免可变的值类型；

105.拆箱转换生成的是哪个值的副本而不是对存储位置的引用；

106.0能隐式转换为任何枚举；

107.要为所有的标志枚举提供等于0的None值；

108.除非它在逻辑上代表单个值，消耗16个字节或更少的存储空间，不可变，而且很少装箱，否则不要定义结构；

九、良构类型

109.为值类型调用ReferenceEquals()将总是返回false；

原因会装箱；

110.垃圾回收器只回收内存，不处理其他资源；

比如（数据库连接，句柄（文件，窗口）等，网络端口以及硬件设备（串口））

111.垃圾回收器处理的事引用对象，只回收堆上的内存；

112.执行垃圾回收时，垃圾回收器不只是枚举所有访问不到的对象，相反，他将所有可达对象紧挨着放到一起，从而覆盖不可访问的对象（垃圾）所占的内存；

113.进程中的所有托管线程都会在垃圾回收期间运行；

114..NET垃圾回收器会以更快的频率尝试清除生存时间较短的对象；

115.编译时不能确定终结器的确定执行时间；

唯一确定的是终结器会在对象最后一次使用之后，并在应用程序正常关闭前的某个时间运行；

116.声明终结器要在类名前加“~”前缀；

没有修饰符，没有返回值，没有参数；

终结器不能显式调用，只有垃圾回收器才能调用；

基类中的终结器作为对象终结调用的一部分被自动调用；

117.终结器不负责回收内存，它们主要负责释放数据库连接和文件句柄这样的资源；

118.要在catch块中使用throw，而不是throw<异常对象>语句；

119.不要引发NullReferenceException；

相反，在值意外为空时引发ArgumentNullException;

十一、泛型

120.泛型类或结构的构造器（和终结器）不要求类型参数；

121.要将只是类型参数数量不同的多个泛型放到同一个文件中；

122.假如同时制定了多个约束，那么类型约束必须第一个出现（就像在类声明中，基类必须先于所实现的接口出现）

123.

124.并非所有的对象都保证有公共默认构造器，

所以编译器不允许为未约束的类型参数调用默认构造器。

125.new() 构造器约束，要求类型实参必须有默认构造器；

126.只能对默认构造器进行约束，

127.泛型类型参数及约束不会被继承；

128.多个接口约束之间是and关系，且不能改为or；

129.委托类型，数组类型和枚举类型不能再基类约束中使用；

130.两个方法可以有相同的名称和形参类型；

只要类型参数的数量不同；

未完待续

《C# 本质论》阅读笔记最先出现在初晴神社。

（由于我还不会图形界面程序的开发，所以使用的Unity _(:з」∠)_）

在开始制作之前，我们需要先去图灵机器人官网申请一个机器人，并获取它的key：

帮助文档：http://www.tuling123.com/help/h_cent_webapi.jhtml?nav=doc

这样前期准备工作就好啦！

接下来我们看下图灵机器人官方给的开发文档：

接口地址：http://www.tuling123.com/openapi/api

请求方式：HTTP POST

         注：若之前使用get请求方式，仍能继续使用,日后将对该请求方式不再进行更新及维护工作，建议采用post请求方式。

请求参数：请求参数格式为json

请求示例

{
                
    “key”: “APIKEY”,
            
    “info”: “今天天气怎么样”，
                
    “loc”：“北京市中关村”，
               
    “userid”：“123456”
                
}
            

部分参数如下：

返回示例

{
                
    "code":100000,
                
    "text":"你也好 嘻嘻"
             
}
           

部分参数如下：

看到这里我们大概有了思路，首先我们将需要发送的文本和key等封装在一个json里，通过post方式发送给图灵机器人的接口地址，然后获取其返回的信息（json格式），解析出来其中的text就是我们想要的结果。

这里我用了Litjson作为json解析工具，首先我创建了一个用于封装发送信息的类RequstData：

其中key是从图灵机器人官网获得的key，info代表发送的文本，userid是区别用户的id，可自定义设置。ConvertToJson()方法将上述信息封装成一个json字符串。

class RequstData
{
    private const string key = "你的KEY";

    public string Key { get; private set; }
    public string Info { get; set; }
    public string UserID { get; set; }


    public RequstData(string info, string userid)
    {
        Info = info;
        UserID = userid;
    }


    public string ConverToJson()
    {
        JsonData jd = new JsonData();
        jd["key"] = key;
        jd["info"] = Info;
        jd["userid"] = UserID;

        return JsonMapper.ToJson(jd);
    }
}

然后是post方法发送并接受数据，返回值为结果字符串，参数postUrl为目标地址，这里就是”http://www.tuling123.com/openapi/api”，paramData就是上面封装的json字符串。

emmmm说实话这部分我也不是很熟悉，自己看吧。。。

/// <summary>
/// Post提交数据
/// </summary>
/// <param name="postUrl">URL</param>
/// <param name="paramData">参数</param>
/// <returns></returns>
private string PostWebRequest(string postUrl, string paramData)
{
    string ret = string.Empty;
    try
    {
        if (!postUrl.StartsWith("http://"))
            return "";

        byte[] byteArray = Encoding.UTF8.GetBytes(paramData); //转化
        HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(new Uri(postUrl));
        webReq.Method = "POST";

        webReq.ContentLength = byteArray.Length;
        Stream newStream = webReq.GetRequestStream();
        newStream.Write(byteArray, 0, byteArray.Length);//写入参数
        newStream.Close();
        HttpWebResponse response = (HttpWebResponse)webReq.GetResponse();
        StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
        ret = sr.ReadToEnd();
        sr.Close();
        response.Close();
        newStream.Close();
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
    return ret;
}

最后是解析获得的json字符串，依旧是利用litjson做解析，还是挺简单的

// 获取到结果字符串
string result = PostWebRequest(url, requstData.ConverToJson()); 
JsonData dejson = JsonMapper.ToObject(result);  
// 通过索引获得text
Debug.Log(dejson["text"].ToString()); 

利用图灵机器人API开发聊天功能最先出现在初晴神社。

思维导图

下载链接

【C#学习笔记】Socket最先出现在初晴神社。

到今天为止终于过了一遍C# _(:з」∠)_

简单复习下，将学过的东西做个整理。

（参考Siki大大的教程）

形式为思维导图，软件名“xmind 8”。

结尾有资料下载链接。

String与StringBuider

正则表达式

英文Regular Expression,是计算机科学的一个重要概念，她使用一种数学算法来解决计算机程序中的文本检索，匹配等问题，正则表达式语言是一种专门用于字符串处理的语言。在很多语言中都提供了对它的支持，c#也不例外，它可以帮我们解决下面的问题：

1，检索：通过正则表达式，从字符串中获取我们想要的部分

2，匹配：判断给定的字符串是否符合正则表达式的过滤逻辑

你可以认为正则表达式表述了一个字符串的书写规则。

判断用户输入的密码是否合法，判断用户输入的邮箱格式是否合法。

下载链接

【C#学习笔记】字符串与正则表达式最先出现在初晴神社。