Day8

一、Dynamic type——动态类型

1、Creating a dynamic object with properties——创建具有属性的动态对象

 dynamic 类型是一种静态类型，但类型为 dynamic 的对象会跳过静态类型检查。因此，不会报告编译器错误。 但是，该错误不会被无限期疏忽。 它将在运行时被捕获，并导致运行时异常。

2、Creating a dynamic variable——创建动态变量

3、Returning dynamic

 二、Type Conversion——类型转换

一般可以直接用类型家括号的形式，强转。或者用convert.类型。进行转换。

1、Explicit Type Conversion——显示类型转换

using System;
namespace TypeConversionApplication
{
 class ExplicitConversion
 {
 static void Main(string[] args)
 {
 double d = 5673.74;
 int i;
 i = (int)d;
 Console.WriteLine(i);// 结果： i = 5673
 Console.ReadKey();
 }
 }
}

2、隐式转换

3、 LINQ Casting operations

double[] doubles = new[]{1,2,3}.Cast<double>().ToArray();//报错
double[] doubles = new[]{1,2,3}.Select(i => (double)i).ToArray();//正解

三、Casting 

1、Checking compatibility without casting 

if(value is int)
{
 Console.WriteLine(value + "is an int");
}

2、Cast an object to a base type

3、Explicit Casting

4、Safe Explicit Casting (`as` operator)

如果不确定一个值是否属于您认为的类型，您可以使用作为运算符安全地强制转换它。如果该值不是该类型的值，则生成的值将为空

object value = "-1";
int? number = value as int?;
if(number != null)
{
 Console.WriteLine(Math.Abs(number.Value));
}

四、Nullable types

1: Initialising a nullable

下面都是判断是否i为null

Nullable<int> i = null;
int? i = null;
var i = (int?)null;
Nullable<int> i = 0;
int? i = 0;

2: Check if a Nullable has a value

int? i = null;
if (i != null)
{
 Console.WriteLine("i is not null");
}
else
{
 Console.WriteLine("i is null");
}

//————————————


if (i.HasValue)
{
 Console.WriteLine("i is not null");
}
else
{
 Console.WriteLine("i is null");
}

3、Get the value of a nullable type

int? i = 10;
int j = i ?? 0;
int j = i.GetValueOrDefault(0);
int j = i.HasValue ? i.Value : 0;

4、Getting a default value from a nullable

class Program
{
 　　static void Main()
 　　{
 　　　　int? nullableExample = null;
 　　　　int result = nullableExample.GetValueOrDefault();
 　　　　Console.WriteLine(result); // will output the default value for int - 0
 　　　　int secondResult = nullableExample.GetValueOrDefault(1);
 　　　　Console.WriteLine(secondResult) // will output our specified default - 1
 　　　　int thirdResult = nullableExample ?? 1;
 　　　　Console.WriteLine(secondResult) // same as the GetValueOrDefault but a bit shorter
   }
}

5、Default value of nullable types is null

public class NullableTypesExample
{
 static int? _testValue;
 public static void Main()
 {
 if(_testValue == null)
 Console.WriteLine("null");
 else
 Console.WriteLine(_testValue.ToString());
 }
}

输出：null

五、Interfaces——接口

1、Implementing an interface——实现一个接口

public interface INoiseMaker
{
 string MakeNoise();
}
public class Cat : INoiseMaker
{
 public string MakeNoise()
 {
 return "Nyan";
 }
}
public class Dog : INoiseMaker
{
 public string MakeNoise()
 {
 return "Woof";
 }
}

2、Implementing multiple interfaces

public interface IAnimal
{
 string Name { get; set; }
}
public interface INoiseMaker
{
 string MakeNoise();
}
public class Cat : IAnimal, INoiseMaker
{
 public Cat()
 {
 Name = "Cat";
 }
 public string Name { get; set; }
 public string MakeNoise()
 {
 return "Nyan";
 }
}

3、使用多接口

using System;
using System.Collections.Generic;

delegate T NumberChanger<T>(T n);

namespace test11._1
{
    public interface IShape
    {
        double ComputeArea();
    }
    class Program
    {
        public static void Main(string[] args)
        {
            var shapes = new List<IShape>() { new Rectangle(5, 10), new Circle(5) };
            ComputeArea(shapes);
            Console.ReadKey();
        }
        private static void ComputeArea(IEnumerable<IShape> shapes)
        {
            foreach (var shape in shapes)
            {
                Console.WriteLine("Area: {0:N}", shape.ComputeArea());25             }
        }
    }
    public class Rectangle : IShape
    {
        private double length;
        private double width;

        public Rectangle(double length, double width)
        {
            this.length = length;
            this.width = width;
        }

        public double ComputeArea()
        {
            return length * width;
        }
    }
    public class Circle : IShape
    {
        private double radius;
        public Circle(double radius)
        {
            this.radius = radius;
        }
        public double ComputeArea()
        {
            return Math.Pow(radius, 2.0) * Math.PI;
        }
    }

}

运行结果：

 六、静态类

1、静态类

“静态”关键字在一个类有三个效果：

1.您不能创建一个静态类的实例（这甚至删除了默认的构造函数）

2.类中的所有属性和方法也必须是静态的。

3.一个静态类是一个密封的类，这意味着它不能被继承。

2、静态类等级

静态类在成员访问上延迟初始化，并在应用程序域期间一直存在。

3、静态类关键字

静态关键字意味着两件事：

1。这个值不会从对象改变到对象，而是在一个类上改变。

2。静态属性和方法不需要一个实例。

public class Foo
{
 public Foo{
 Counter++;
 NonStaticCounter++;
 }
 public static int Counter { get; set; }
 public int NonStaticCounter { get; set; }
}
public class Program
{
 static void Main(string[] args)
 {
 //创建实例
 var foo1 = new Foo();
 Console.WriteLine(foo1.NonStaticCounter); //结果 "1"
 //这个下一个调用并不访问实例，而是通过类名进行调用。
 Console.WriteLine(Foo.Counter); //结果 "1"
 //创建第二个实例
 var foo2 = new Foo();
 Console.WriteLine(foo2.NonStaticCounter); //结果 "1"
 Console.WriteLine(Foo.Counter); //结果 "2"
 //静态属性在两个实例上都递增，并且可以对整个类持续化
}

七、Singleton Implementation——单例实现

1、Statically Initialized Singleton——静态初始化的实例

public class Singleton
{
 private readonly static Singleton instance = new Singleton();
 private Singleton() { }
 public static Singleton Instance => instance;
}

这个实现是线程安全的，因为在这种情况下，实例对象是在静态构造函数中初始化的。CLR已经确保了所有静态构造函数都是以线程安全执行的。突变实例不是一个线程安全的操作，因此只读属性保证了初始化后的不变性。

2、 Lazy, thread-safe Singleton (using Lazy<T>)

 八、依赖注入

1、Dependency Injection C# and ASP.NET with Unity

首先，为什么我们要在代码中使用依赖注入？我们希望将其他组件从其他我们程序中的类。例如，我们有一个类AnimalController，它有这样的代码:

public class AnimalController()
{
 private SantaAndHisReindeer _SantaAndHisReindeer = new SantaAndHisReindeer();
 public AnimalController(){
 Console.WriteLine("");
 }
}

九、部分类和方法

1、部分类

部分类提供了将类声明（通常分割为单独的文件）的能力。可以用部分类解决的一个常见问题是，允许用户修改自动生成的代码，而不用担心如果重新生成代码，他们的更改会被覆盖。此外，多个开发人员还可以使用同一个类或方法。

 2、 Partial classes inheriting from a base class

您不能在多个部分类中指定不同的基类，这将导致编译器错误。例如：

public partial class PartialClass : BaseClass {} ；//错误
public partial class PartialClass : OtherBaseClass {} ；//错误

3、Partial methods

 部分方法由一个部分类声明中的定义（作为一个常见的场景-在自动生成的场景中）和在另一个部分类声明中的实现组成。

using System;
namespace PartialClassAndMethods
{
 public partial class PartialClass // 自动生成
 {
 partial void PartialMethod();
 }
 public partial class PartialClass // 人为写的
 {
 public void PartialMethod()
 {
 Console.WriteLine("Partial method called.");
 }
 }
 class Program
 {
 static void Main(string[] args)
 {
 PartialClass partial = new PartialClass();
 partial.PartialMethod(); // outputs "Partial method called."
 }
 }
}

十、方法

1、 Calling a Method——调用方法

调用静态方法

System.Console.WriteLine("Hello World"); 

string name = "User";
System.Console.WriteLine("Hello, {0}!", name);

调用一个静态方法并存储其返回值：

string input = System.Console.ReadLine();

调用实例方法

int x = 42;
string xAsString = x.ToString();

2、Anonymous method

匿名方法提供了一种将代码块作为委托参数传递的技术。它们是带有身体的方法，但没有名字。

delegate int IntOp(int lhs, int rhs);
class Program
{
 static void Main(string[] args)
 {
 // C# 2.0 definition
 IntOp add = delegate(int lhs, int rhs)
 {
 return lhs + rhs;
 };
 // C# 3.0 definition
 IntOp mul = (lhs, rhs) =>
 {
 return lhs * rhs;
 };
 // C# 3.0 definition - shorthand
 IntOp sub = (lhs, rhs) => lhs - rhs;
 // Calling each method
 Console.WriteLine("2 + 3 = " + add(2, 3));
 Console.WriteLine("2 * 3 = " + mul(2, 3));
 Console.WriteLine("2 - 3 = " + sub(2, 3));
 }
}