股票量化交易软件-☀️ 学会编程入门必备 C 最基础知识介绍六接口命名空间预处理指令正则表达式异常处理

上一篇文章介绍了C#的OOP思想，不知道大家吃透了没，本篇文章是C#基础知识的最后一篇啦看完这篇文章大家是不是都学会了C#呢，嘿嘿下面开始介绍本篇的内容了——股票量化交易软件,接口、命名空间、预处理指令、正则表达式、异常处理、文件的输入与输出

股票量化交易软件,接口(interfac????

股票量化交易软件,接口定义了所有类继承股票量化交易软件,接口时应遵循的语法合同。股票量化交易软件,接口定义了语法合同“是什么”部分，派生类定义了语法合同“怎么做”部分。股票量化交易软件,接口定义了属性、方法和事件，这些都是股票量化交易软件,接口的成员。股票量化交易软件,接口只包含了成员的声明。成员的定义是派生类的责任。股票量化交易软件,接口提供了派生类应遵循的标准结构。股票量化交易软件,接口使得实现股票量化交易软件,接口的类或结构在形式上保持一致。

抽象类在某种程度上与股票量化交易软件,接口类似，它们大多只是用在当只有少数方法由基类声明由派生类实现时。

定义股票量化交易软件,接口:MyInterfaccs

股票量化交易软件,接口使用interface关键字声明，它与类的声明类似。股票量化交易软件,接口声明默认是public的。下面是一个股票量化交易软件,接口声明的实例：

以上代码定义了股票量化交易软件,接口IMyInterface。通常股票量化交易软件,接口命令以I字母开头，这个股票量化交易软件,接口只有一个方法MethodToImplement()，没有参数和返回值，当然我们可以按照需求设置参数和返回值。

值得注意的是，该方法并没有具体的实现。

接下来我们来实现以上股票量化交易软件,接口：InterfaceImplementer.cs

实例
using System;

interface IMyInterface
{
        // 股票量化交易软件,接口成员
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine('MethodToImplement() called.');
    }
}

InterfaceImplementer类实现了IMyInterface股票量化交易软件,接口，股票量化交易软件,接口的实现与类的继承语法格式类似：

继承股票量化交易软件,接口后，我们需要实现股票量化交易软件,接口的方法MethodToImplement(),方法名必须与股票量化交易软件,接口定义的方法名一致。

以下实例定义了两个股票量化交易软件,接口IMyInterface和IParentInterface。

如果一个股票量化交易软件,接口继承其他股票量化交易软件,接口，那么实现类或结构就需要实现所有股票量化交易软件,接口的成员。

以下实例IMyInterface继承了IParentInterface股票量化交易软件,接口，因此股票量化交易软件,接口实现类必须实现MethodToImplement()和ParentInterfaceMethod()方法：

实例
using System;

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }

    public void MethodToImplement()
    {
        Console.WriteLine('MethodToImplement() called.');
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine('ParentInterfaceMethod() called.');
    }
}

实例输出结果为：

C#命名空间????

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。

☀️ 学会编程入门必备 C 最基础知识介绍六接口命名空间预处理指令正则表达式异常处理

定义命名空间

命名空间的定义是以关键字namespace开始，后跟命名空间的名称，如下所示：

为了调用支持命名空间版本的函数或变量，会把命名空间的名称置于前面，如下所示：

下面的程序演示了命名空间的用法：

实例
using System;
namespace first_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine('Inside first_space');
      }
   }
}
namespace second_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine('Inside second_space');
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

using关键字

using关键字表明程序使用的是给定命名空间中的名称。例如，我们在程序中使用System命名空间，其中定义了类Console。我们可以只写：

我们可以写完全限定名称，如下：

也可以使用using命名空间指令，这样在使用的时候就不用在前面加上命名空间名称。该指令告诉编译器随后的代码使用了指定命名空间中的名称。下面的代码演示了命名空间的应用。

让我们使用using指定重写上面的实例：

实例
using System;
using first_space;
using second_space;

namespace first_space
{
   class abc
   {
      public void func()
      {
         Console.WriteLine('Inside first_space');
      }
   }
}
namespace second_space
{
   class efg
   {
      public void func()
      {
         Console.WriteLine('Inside second_space');
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

嵌套命名空间

命名空间可以被嵌套，即您可以在一个命名空间内定义另一个命名空间，如下所示：

可以使用点运算符访问嵌套的命名空间的成员，如下所示：

实例
using System;
using SomeNameSpace;
using SomeNameSpace.Nested;

namespace SomeNameSpace
{
    public class MyClass
    {
        static void Main()
        {
            Console.WriteLine('In SomeNameSpace');
            Nested.NestedNameSpaceClass.SayHello();
        }
    }

    // 内嵌命名空间
    namespace Nested  
    {
        public class NestedNameSpaceClass
        {
            public static void SayHello()
            {
                Console.WriteLine('In Nested');
            }
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

C#预处理器指令????

预处理器指令指导编译器在实际编译开始之前对信息进行预处理。

所有的预处理器指令都是以#开始。且在一行上，只有空白字符可以出现在预处理器指令之前。预处理器指令不是语句，所以它们不以分号结束。

C#编译器没有一个单独的预处理器，指令被处理时就像是有一个单独的预处理器一样。在C#中，预处理器指令用于在条件编译中起作用。与C和C++不同的是，它们不是用来创建宏。一个预处理器指令必须是该行上的唯一指令。

C#预处理器指令列表

下表列出了C#中可用的预处理器指令：

#define	它用于定义一系列成为符号的字符。
#undef	它用于取消定义符号。
#if	它用于测试符号是否为真。
#else	它用于创建复合条件指令，与 #if 一起使用。
#elif	它用于创建复合条件指令。
#endif	指定一个条件指令的结束。
#line	它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。
#error	它允许从代码的指定位置生成一个错误。
#warning	它允许从代码的指定位置生成一级警告。
#region	它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。
#endregion	它标识着 #region 块的结束。

#define预处理器

#define预处理器指令创建符号常量。

#define允许定义一个符号，这样，通过使用符号作为传递给#if指令的表达式，表达式将返回true。它的语法如下：

下面的程序说明了这点：

实例
#define PI
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine('PI is defined');
         #else
            Console.WriteLine('PI is not defined');
         #endif
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

条件指令

可以使用#if指令来创建一个条件指令。条件指令用于测试符号是否为真。如果为真，编译器会执行#if和下一个指令之间的代码。

条件指令的语法：

其中，symbol是要测试的符号名称。也可以使用true和false，或在符号前放置否定运算符。

常见运算符有：

==(等于)!=(不等于)&&(与)||(或)

也可以用括号把符号和运算符进行分组。条件指令用于在调试版本或编译指定配置时编译代码。一个以#if指令开始的条件指令，必须显示地以一个#endif指令终止。

下面的程序演示了条件指令的用法：

实例
#define DEBUG
#define VC_V10
using System;
public class TestClass
{
   public static void Main()
   {

      #if (DEBUG && !VC_V10)
         Console.WriteLine('DEBUG is defined');
      #elif (!DEBUG && VC_V10)
         Console.WriteLine('VC_V10 is defined');
      #elif (DEBUG && VC_V10)
         Console.WriteLine('DEBUG and VC_V10 are defined');
      #else
         Console.WriteLine('DEBUG and VC_V10 are not defined');
      #endif
      Console.ReadKey();
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

C#正则表达式????

正则表达式是一种匹配输入文本的模式。

.Net框架提供了允许这种匹配的正则表达式引擎。模式由一个或多个字符、运算符和结构组成。如果还不理解正则表达式可以阅读正则表达式-教程。

定义正则表达式

下面列出了用于定义正则表达式的各种类别的字符、运算符和结构。

字符转义字符类定位点分组构造限定符反向引用构造备用构造替换杂项构造

字符转义正则表达式中的反斜杠字符指示其后跟的字符是特殊字符，或应按原义解释该字符。下表列出了转义字符：字符类字符类与一组字符中的任何一个字符匹配。下表列出了字符类：分组构造分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。这一部分比较难于理解，可以阅读正则表达式-选择、正则表达式的先行断言(lookahea和后行断言(lookbehin帮助理解。

下表列出了分组构造：

实例
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = '1851 1999 1950 1905 2003';
      string pattern = @'(?<=19)d{2}';

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}

限定符限定符指定在输入字符串中必须存在上一个元素的多少个实例才能出现匹配项。限定符包括下表中列出的语言元素。

下表列出了限定符：

反向引用构造反向引用允许在同一正则表达式中随后标识以前匹配的子表达式。

下表列出了反向引用构造：备用构造备用构造用于修改正则表达式以启用either/or匹配。

下表列出了备用构造：替换替换是替换模式中使用的正则表达式。

下表列出了用于替换的字符：

杂项构造下表列出了各种杂项构造：Regex类Regex类用于表示一个正则表达式。

下表列出了Regex类中一些常用的方法：如需了解Regex类的完整的属性列表，请参阅微软的C#文档。

实例1下面的实例匹配了以‘S’开头的单词：

实例
using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine('The Expression: ' + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = 'A Thousand Splendid Suns';

         Console.WriteLine('Matching words that start with 'S': ');
         showMatch(str, @'SS*');
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

实例2下面的实例匹配了以‘m’开头以‘e’结尾的单词：

实例
using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine('The Expression: ' + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = 'make maze and manage to measure it';

         Console.WriteLine('Matching words start with 'm' and ends with 'e':');
         showMatch(str, @'mS*e');
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Matchingwordsstartwith‘m’andendswith‘e’:TheExpression:mS*emakemazemanagemeasure

实例3下面的实例替换掉多余的空格：

实例
using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = 'Hello   World   ';
         string pattern = 's+';
         string replacement = ' ';
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine('Original String: {0}', input);
         Console.WriteLine('Replacement String: {0}', result);    
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

C#异常处理????

异常是在程序执行期间出现的问题。C#中的异常是对程序运行时出现的特殊情况的一种响应，比如尝试除以零。

异常提供了一种把程序控制权从某个部分转移到另一个部分的方式。C#异常处理时建立在四个关键词之上的：try、catch、finally和throw。

try：一个try块标识了一个将被激活的特定的异常的代码块。后跟一个或多个catch块。catch：程序通过异常处理程序捕获异常。catch关键字表示异常的捕获。finally：finally块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。throw：当问题出现时，程序抛出一个异常。使用throw关键字来完成。

假设一个块将出现异常，一个方法使用try和catch关键字捕获异常。try/catch块内的代码为受保护的代码，使用try/catch语法如下所示：

try
{
   // 引起异常的语句
}
catch( ExceptionName e1 )
{
   // 错误处理代码
}
catch( ExceptionName e2 )
{
   // 错误处理代码
}
catch( ExceptionName eN )
{
   // 错误处理代码
}
finally
{
   // 要执行的语句
}

可以列出多个catch语句捕获不同类型的异常，以防try块在不同的情况下生成多个异常。

C#中的异常类

C#异常是使用类来表示的。C#中的异常类主要是直接或间接地派生于SysteException类。SysteApplicationException和SysteSystemException类是派生于SysteException类的异常类。

SysteApplicationException类支持由应用程序生成的异常。所以程序员定义的异常都应派生自该类。

SysteSystemException类是所有预定义的系统异常的基类。

下表列出了一些派生自SysteSystemException类的预定义的异常类：

System.IO.IOException	处理 I/O 错误
System.IndexOutOfRangeException	处理当方法指向超出范围的数组索引时生成的错误
System.ArrayTypeMismatchException	处理当数组类型不匹配时生成的错误
System.NullReferenceException	处理当依从一个空对象时生成的错误
System.DivideByZeroException	处理当除以零时生成的错误
System.InvalidCastException	处理在类型转换期间生成的错误
System.OutOfMemoryException	处理空闲内存不足生成的错误
System.StackOverflowException	处理栈溢出生成的错误

异常处理

C#以try和catch块的形式提供了一种结构化的异常处理方案。使用这些块，把核心程序语句与错误处理语句分离开。

这些错误处理块是使用try、catch和finally关键字实现的。下面是一个当除以零时抛出异常的实例：

实例
using System;
namespace ErrorHandlingApplication
{
    class DivNumbers
    {
        int result;
        DivNumbers()
        {
            result = 0;
        }
        public void pision(int num1, int num2)
        {
            try
            {
                result = num1 / num2;
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine('Exception caught: {0}', e);
            }
            finally
            {
                Console.WriteLine('Result: {0}', result);
            }

        }
        static void Main(string[] args)
        {
            DivNumbers d = new DivNumbers();
            d.pision(25, 0);
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Exceptioncaught:SysteDivideByZeroException:Attemptedtopidebyzero.at…Result:0

创建用户自定义异常

也可以定义自己的异常。用户自定义的异常类是派生自ApplicationException类。下面的实例演示了这点：

实例
using System;
namespace UserDefinedException
{
   class TestTemperature
   {
      static void Main(string[] args)
      {
         Temperature temp = new Temperature();
         try
         {
            temp.showTemp();
         }
         catch(TempIsZeroException e)
         {
            Console.WriteLine('TempIsZeroException: {0}', e.Message);
         }
         Console.ReadKey();
      }
   }
}
public class TempIsZeroException: ApplicationException
{
   public TempIsZeroException(string message): base(message)
   {
   }
}
public class Temperature
{
   int temperature = 0;
   public void showTemp()
   {
      if(temperature == 0)
      {
         throw (new TempIsZeroException('Zero Temperature found'));
      }
      else
      {
         Console.WriteLine('Temperature: {0}', temperature);
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

抛出对象

如果异常是直接或间接派生自SysteException类，我们可以抛出一个对象。可以在catch块中使用throw语句来抛出当前的对象，如下所示：

C#文件的输入与输出⛄️

从根本上说，流是通过通信路径传递的字节序列。有两个主要的流：输入流和输出流。输入流用于从文件读取数据，输出流用于向文件写入数据。

C#I/O类

SysteIO命名空间有各种不同的类，用于执行各种文件操作，如创建和删除文件、读取或写入文件，关闭文件等。

下表列出了一些SysteIO命名空间中常用的非抽象类：

SysteIO命名空间中的FileStream类有助于文件的读写与关闭。该类派生自抽象类Stream。

您需要创建一个FileStream对象来创建一个新的文件，或打开一个已有的文件。创建FileStream对象的语法如下：

FileStream  = new FileStream( ,
, , );

例如，创建一个FileStream对象F来读取名为sampltxt的文件：

FileStream F = new FileStream('sample.txt', FileMode.Open, FileAccess.Read, FileShare.Read);

实例下面的程序演示了FileStream类的用法：

实例
using System;
using System.IO;

namespace FileIOApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            FileStream F = new FileStream('test.dat',
            FileMode.OpenOrCreate, FileAccess.ReadWrite);

            for (int i = 1; i <= 20; i++)
            {
                F.WriteByte((byte)i);
            }

            F.Position = 0;

            for (int i = 0; i <= 20; i++)
            {
                Console.Write(F.ReadByte() + ' ');
            }
            F.Close();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

C#高级文件操作

上面的实例演示了C#中简单的文件操作。要充分利用C#SysteIO类的强大功能，需要知道这些类常用的属性和方法。

我们将讨论这些类和它们执行的操作。请单击链接详细了解各个部分的知识：C#高级文件操作

总结????

本篇文章介绍了C#中一些基础知识，是接着上一篇博客写的主要介绍了C#中的股票量化交易软件,接口、命名空间、预处理指令、正则表达式、异常处理、文件的输入与输出

到目前为止，C#基础知识可基本就介绍完啦，小伙伴们有没有认真看这六篇文章呢。认真看完学会你就差不多是C#初级开发工程师了哈哈高级知识还有很多，我会继续努力学习哒????

C#基础知识传送门

文章为作者独立观点，不代表股票程序化软件自动交易接口观点

股票量化交易软件-☀️ 学会编程入门必备 C 最基础知识介绍六接口命名空间预处理指令正则表达式异常处理

股票量化交易软件-接口测试工具Postman接口测试图文教程_niaonao

股票量化交易软件-1接口切换流程图_如何进行接口测试?如何做好接口测试?A

股票量化交易软件-java接口 interface__卓凡的博客

股票量化交易软件-编写API文档给到前端?_衍欲瑜的博客_后端怎么写接口