c# 笔记(未整理)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

//抽象类可以被抽象类继承
//抽象方法只能包含在抽象类中
//抽象方法没有方法体
//抽象方法必须在普通类里面实现
//抽象方法在派生的抽象类内不必实现,但也可实现
//虚方法必须有方法体
//虚方法可以在派生类(无论是抽象类还是普通类)重写或者不重写
//sealed修饰类时,表示该类不能被其他类继承
//sealed修饰方法时,通常与override关键字一起使用,标记一个方法作为sealed以防止在继承链中进一步重写
public abstract class Test {
    public abstract void Eat();
    public virtual void Eat1() {
    }
}
 
public abstract class Test1 : Test {
    public override void Eat() {
    }
 
    public override void Eat1() {
        base.Eat1();
    }
    public abstract void Eat2();
}
 
public class Test2 : Test1 {
    public override void Eat() {
    }
 
    public override void Eat1() {
        base.Eat1();
    }
 
    public override void Eat2() {
    }
}
 
public sealed class Test3 : Test1 {
    public sealed override void Eat2() {
    }
}
 
//一、源代码复用
//1、单一文件共享:文件夹-->添加-->现有项-添加为链接(添加按钮下拉)
//2、多文件共享:新建项目-->共享项目
 
//二、程序集复用
//1、Retargetable程序集:只要求目标程序集具有相同的文件名即可
//2、类型转移:如果项目需要提供类似的向后兼容行，也可以使用这个特性
 
//虚方法具有默认实现,虚方法不一定需要重写，子类继承了父类的方法及默认实现
//抽象方法只能存在于抽象类中，抽象方法没有方法体(方法的定义,但没有实现),且必须要重写
//C:\Program Files\dotnet\shared\Microsoft.NETCore.App\xxx\System.Private.CoreLib.dll
 
//模板方法:该模式主张将一个可复用的工作流程或者由多个步骤组成的算法定义成模板方法，组成这个流程或者算法的单一步骤则在相应的虚方法之中实现，模板方法根据预先编排的流程调用这些虚方法。这些方法均定义在一个类中，可以通过派生该类并重写相应的虚方法的方式达到对流程定制的目的。
//工厂方法:其实就是在某个类中定义用来提供所需服务对象的方法，这个方法可以是一个单纯的抽象方法，也可以是具有默认实现的虚方法，至于方法声明的返回类型，可以是一个接口或者抽象类，也可以是未封闭（Sealed）的具体类型。派生类型可以采用重写工厂方法的方式提供所需的服务对象。
//抽象工厂:工厂方法利用定义在某个类型的抽象方法或者虚方法完成了针对“单一对象”的提供，而抽象工厂则利用一个独立的接口或者抽象类提供“一组相关的对象”。具体来说，我们需要定义一个独立的工厂接口或者抽象工厂类，并在其中定义多个工厂方法来提供“同一系列”的多个相关对象。如果希望抽象工厂具有一组默认的“产出”，也可以将一个未被封闭的类型作为抽象工厂，以虚方法形式定义的工厂方法将默认的对象作为返回值。在具体的应用开发中，可以通过实现工厂接口或者继承抽象工厂类（不一定是抽象类）的方式来定义具体工厂类，并利用它来提供一组定制的对象系列。
 
//只读属性,仅能在类的构造器方法中才能赋值
public string FirstName { get; }
public string FirstName { get; } = "Test";
 
public abstract class TestClass1 {
    protected abstract void TestMethod1();
    protected virtual void TestMethod2() { }
}
 
public class TestClass2 : TestClass1 {
    protected override void TestMethod1() {
    }
    protected sealed override void TestMethod2() { }
}
 
public class TestClass3 : TestClass2 {
    protected override void TestMethod1() {
    }
    public dynamic GetDynamicObject() {
        return new { Id = Guid.Empty, Name = "" };
    }
    public dynamic GetDynamicObject(dynamic dynamicObject) {
        return dynamicObject;
    }
    public T GetGenericObject<T, K>(T t, K k) where T : class, IDisposable where K : new() {
        return t;
    }
}
 
//构造函数继承(Constructors Inheritance)
//构造函数可以使用 base 关键字调用基类的构造函数
//base 关键字可带参数使用,也可不带参数使用
//如果不使用 base 关键字来显式调用基类构造函数,则将隐式调用无参数构造函数（若有）
//如果基类没有提供无参数构造函数，派生类必须使用 base 显式调用基类构造函数
//this 关键字调用同一对象中的另一构造函数
//和 base 一样，this 可带参数使用也可不带参数使用,构造函数中的任何参数都可用作 this 的参数,或者用作表达式的一部分
//new 关键字可以显式隐藏从基类继承的成员
public class Foo : FooParent {
    public IBar Bar { get; }
    public IBaz Baz { get; }
    public IBaw Baw { get; }
    public Foo(IBar bar) => Bar = bar;
    public Foo(IBar bar, IBaz baz) : base(bar) {
        this.Bar = bar;
        this.Baz = baz;
    }
    public Foo(IBar bar, IBaz baz, IBaw baw) : this(bar) {
        this.Bar = bar;
        this.Baz = baz;
        this.Baw = baw;
    }
    public new void SayHello() { }
}
public class FooParent {
    public FooParent() { }
    public FooParent(IBar bar) { }
    public void SayHello() { }
}
public interface IBar { }
public interface IBaz { }
public interface IBaw { }
 
//基类
public class Base {
    //构造函数
    public Base() {
        Console.WriteLine("Inside Base Constructor");
    }
    //析构函数
    //"~" Finalizers 终结器:
    //无法在结构中定义终结器,它们仅用于类
    //一个类只能有一个终结器
    //不能继承或重载终结器
    //不能手动调用终结器, 可以自动调用它们
    //终结器不使用修饰符或参数
    ~Base() {
        Console.WriteLine("Inside Base Destructor");
    }
}
 
//派生类
public class Derived : Base {
    public Derived() {
        Console.WriteLine("Inside The Derived Constructor");
    }
    ~Derived() {
        Console.WriteLine("Inside The Derived Destructor");
    }
}
 
public class WriteStringTest {
    //字段
    public Type type;
    //属性
    public Type Type { get; set; }
    //方法
    public static void WriteString() {
        for (int i = 0; i < 10; i++) {
            WriteString(i.ToString());
        }
 
        //Local Functions(本地函数/本地方法)
        void WriteString(string s) {
            Console.WriteLine(s);
        }
    }
}
 
//左操作数为null,则计算右操作数
List<string> strs = new List<string> { "a", "b" };
strs ??= new List<string> { "c", "d" };
strs.ForEach(x => {
    Console.WriteLine(x);
});
 
//let子句
var nums = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var query = from num in nums
            let num2 = (
                    from n in nums
                    where n % 2 == 0
                    select n
            )
            select num * num2.Count();
foreach (var item in query) {
    Console.WriteLine(item);
}
 
//ref是表明parameter可能会被方法所改变,需要初始化
//out是表明parameter一定会被方法所改变,不需要初始化
//in是表明parameter不能被方法所改变,需要初始化
 
//Func<T, bool>是对delegate bool Predicate<T>(T obj)的简化
//Predicate<T>又是对Func<T, bool>的简化