网站 字号 英文html知识点整理
目录
一.结构体
二.特殊的结构体(ref struct):
三.枚举
四.泛型
泛型的使用:
1.泛型类:定义一个泛型类,使用类型参数T
2.泛型方法:在方法定义中使用类型参数
3.泛型接口
五.委托及泛型委托
委托
泛型委托
六.事件
事件:
泛型事件:使用泛型委托（如EventHandler）来声明事件，可以传递更具体的事件数据。
七.事件,委托,泛型结合使用
总结
一.结构体
定义：
struct关键字用于声明一个值类型.结构体适合表示轻量级对象,如坐标,复杂数等
特点:
- 值类型:数据存储在栈（Stack）上,变量直接包含数据值
- 不可继承:结构体不支持继承（无法被继承，也不能继承自其他类型，除了实现接口）
- 默认不可为空:值类型变量默认情况下不能为null（除非使用Nullable<T>）
- 内存效率:在栈上分配和释放,效率较高,适合小型数据结构
用法:
- 不适合过大的数据结构,否则会影响性能
- 结构体应设计为不可变（Immutability）,即成员应尽量设为只读
代码示例:
public struct Point
{public double X { get; }public double Y { get; }public Point(double x, double y){X = x;Y = y;}
}
二.特殊的结构体(ref struct):
定义:
- ref struct是一种特殊的结构体,限制其只能在栈上分配,不能在堆上分配
特点:
- 仅限栈分配:ref struct实例不能被分配到托管堆上,保证了高性能的内存访问
- 无法装箱:不能转换为object类型,不能使用如泛型,接口等需要装箱的特性
- 用途限定:常用于需要高性能和低延迟的场景,例如Span<T>,ReadonlySpan<T>等类型
限制:
- 不能捕获到异步方法,迭代器或Lambda表达式中:因为这些场景中可能导致变量逃逸出栈
- 不能赋值给类型为
object的变量 - 不能实现接口
代码示例:
public ref struct SpanWrapper
{private Span<byte> _buffer;public SpanWrapper(Span<byte> buffer){_buffer = buffer;}// 成员方法和属性
}
三.枚举
定义:enum关键字用于声明一个枚举类型,由命名常量的集合组成
特点:
- 值类型:枚举的底层类型是整型（默认是int）,每个枚举成员都有一个关联的整数值
- 提高可读性:使用有意义的名称代替数字,提高代码的可读性和可维护性
- 可指定底层类型:可以显式指定底层类型,例如byte,short等
- 位标志（Flags）:使用
[Flags]属性可以让枚举表示位域,支持按位操作
代码示例:
public enum DaysOfWeek : byte
{Sunday = 0,Monday = 1,Tuesday = 2,Wednesday = 3,Thursday = 4,Friday = 5,Saturday = 6
}// 使用枚举
DaysOfWeek today = DaysOfWeek.Monday;
位标志代码示例:
[Flags]
public enum FileAccess
{Read = 1,Write = 2,Execute = 4
}// 组合权限
FileAccess readWrite = FileAccess.Read | FileAccess.Write; // 1|2=3
//同时拥有读和写的权限
四.泛型
定义:
- 泛型是C# 2.0引入的一个特性,允许在定义类,接口,方法和委托时,使用类型参数,从而实现代码的类型安全和重用性
优势:
- 类型安全：在编译时检查类型，防止由于类型不匹配导致的运行时错误。
- 性能提升：避免了装箱（boxing）和拆箱（unboxing）的开销。
- 代码重用：编写一次代码，可适用于多种数据类型。
泛型的使用:
1.泛型类:定义一个泛型类,使用类型参数T
定义泛型类:
public class GenericClass<T>
{private T _value;public GenericClass(T value){_value = value;}public T GetValue(){return _value;}
}
使用泛型类:
GenericClass<int> intInstance = new GenericClass<int>(10);
int intValue = intInstance.GetValue(); // intValue = 10GenericClass<string> stringInstance = new GenericClass<string>("Hello");
string stringValue = stringInstance.GetValue(); // stringValue = "Hello"
2.泛型方法:在方法定义中使用类型参数
定义泛型方法:
public class Utility
{public void Swap<T>(ref T a, ref T b){T temp = a;a = b;b = temp;}
}
使用泛型方法:
Utility utility = new Utility();
int x = 5, y = 10;
utility.Swap<int>(ref x, ref y); // 交换整数string s1 = "First", s2 = "Second";
utility.Swap<string>(ref s1, ref s2); // 交换字符串
3.泛型接口
定义一个泛型接口:
public interface IRepository<T>
{void Add(T item);T Get(int id);
}
实现泛型接口:
public class Repository<T> : IRepository<T>
{private List<T> _items = new List<T>();public void Add(T item){_items.Add(item);}public T Get(int id){return _items[id];}
}
五.委托及泛型委托
委托
定义:
- 委托是C#中的一种数据类型，它定义了一个方法的类型，使得方法可以作为参数传递。委托类似于函数指针，但它是类型安全的。
基本语法:public delegate 返回类型 委托名(参数列表);
定义委托:
public delegate int MathOperation(int a, int b);
使用委托:
public class Calculator
{public int Add(int a, int b) => a + b;public int Subtract(int a, int b) => a - b;
} public class Program
{// 定义一个委托类型public delegate int Operation(int x, int y);public static void Main(){Calculator calc = new Calculator();// 创建委托实例并指向Add方法Operation op = new Operation(calc.Add);Console.WriteLine(op(3, 4)); // 输出: 7// 改变委托指向Subtract方法op = new Operation(calc.Subtract);Console.WriteLine(op(10, 4)); // 输出: 6}
}
泛型委托
使用泛型参数的委托类型,增强了委托的灵活性和可重用性
常用的泛型委托:
Func<T1,...,TResult>:有返回值的委托,可有0到16个输入参数
Func<int, int, int> multiply = (a, b) => a * b;
int product = multiply(3, 4); // product = 12
Action<T1,...>：无返回值的委托，可有0到16个输入参数。
Action<string> display = message => Console.WriteLine(message);
display("Hello, World!"); // 输出：Hello, World!
Predicate<T>：返回bool类型的委托，常用于条件判断。
Predicate<int> isPositive = number => number > 0;
bool check = isPositive(5); // check = true
自定义泛型委托:
public delegate TOutput Converter<TInput, TOutput>(TInput input);class Program
{static void Main(){Converter<double, int> doubleToInt = num => (int)num;int result = doubleToInt(3.14); // result = 3}
}
六.事件
定义:
- 事件是委托的特殊形式,用于在对象之间传递消息或通知.当对象的状态发生改变时,可以通过事件通知订阅者.事件是基于“发布-订阅”（Publish-Subscribe）模式的实现
基本语法:public event 委托类型 事件名;
事件:
定义委托和事件:
// 定义委托
public delegate void NotifyEventHandler(string message);// 定义发布者类
public class Publisher
{// 声明事件public event NotifyEventHandler Notify;public void DoSomething(){// 执行某些操作// 触发事件OnNotify("事件被触发.");}protected virtual void OnNotify(string message){// 检查是否有订阅者Notify?.Invoke(message);}
}
订阅事件:
// 定义订阅者类
public class Subscriber
{public void OnNotified(string message){Console.WriteLine($"Received message: {message}");}
}
使用事件:
Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();// 订阅事件
publisher.Notify += subscriber.OnNotified;// 触发事件
publisher.DoSomething(); // 输出：Received message: 事件被触发.
泛型事件:使用泛型委托（如EventHandler<TEventArgs>）来声明事件，可以传递更具体的事件数据。
使用EventHandler<TEventArgs>:
// 定义事件参数类
public class ProgressEventArgs : EventArgs
{public int Percentage { get; set; }
}// 定义发布者类
public class Process
{// 声明泛型事件public event EventHandler<ProgressEventArgs> ProgressChanged;public void StartProcess(){for (int i = 0; i <= 100; i += 10){// 模拟处理过程// 触发事件OnProgressChanged(i);}}protected virtual void OnProgressChanged(int percentage){ProgressChanged?.Invoke(this, new ProgressEventArgs { Percentage = percentage });}
}
订阅泛型事件:
public class Listener
{public void Subscribe(Process process){process.ProgressChanged += OnProgressChanged;}private void OnProgressChanged(object sender, ProgressEventArgs e){Console.WriteLine($"Process is {e.Percentage}% complete.");}
}
使用泛型事件:
Process process = new Process();
Listener listener = new Listener();listener.Subscribe(process);
process.StartProcess();// 输出：
// Process is 0% complete.
// Process is 10% complete.
// ...
// Process is 100% complete.
七.事件,委托,泛型结合使用
代码示例:
// 定义泛型委托
public delegate void ValueChangedEventHandler<T>(object sender, ValueChangedEventArgs<T> e);// 定义泛型事件参数类
public class ValueChangedEventArgs<T> : EventArgs
{public T OldValue { get; set; }public T NewValue { get; set; }
}// 定义发布者类
public class ObservableProperty<T>
{private T _value;// 声明泛型事件public event ValueChangedEventHandler<T> ValueChanged;public T Value{get => _value;set{if (!_value.Equals(value)){T oldValue = _value;_value = value;OnValueChanged(oldValue, _value);}}}protected virtual void OnValueChanged(T oldValue, T newValue){ValueChanged?.Invoke(this, new ValueChangedEventArgs<T> { OldValue = oldValue, NewValue = newValue });}
}// 定义订阅者类
public class PropertyObserver<T>
{public void Subscribe(ObservableProperty<T> property){property.ValueChanged += OnValueChanged;}private void OnValueChanged(object sender, ValueChangedEventArgs<T> e){Console.WriteLine($"Value changed from {e.OldValue} to {e.NewValue}");}
}
使用示例:
ObservableProperty<string> nameProperty = new ObservableProperty<string> { Value = "Alice" };
PropertyObserver<string> observer = new PropertyObserver<string>();observer.Subscribe(nameProperty);
nameProperty.Value = "Bob"; // 输出：Value changed from Alice to Bob
总结
-
泛型(Generics):允许在类,接口,方法和委托中使用类型参数,提高了代码的类型安全性和重用性
-
委托(Delegate):是用于引用方法的类型,支持将方法作为参数传递.泛型委托增强了委托的灵活性
-
事件(Event):基于委托的发布-订阅机制,用于在对象间发送通知和消息.泛型事件可以传递特定类型的数据,使事件处理更加强大和类型安全