EPPlus 冻结首行
sheet.View.FreezePanes(2, 1);
EPPlus 冻结多列
sheet.View.FreezePanes(1, 5);
EPPlus 冻结首行
sheet.View.FreezePanes(2, 1);
EPPlus 冻结多列
sheet.View.FreezePanes(1, 5);
SQLite 仅有四个基元数据类型:INTEGER、REAL、TEXT 和 BLOB。 将数据库值返回为 object
的 API 只返回这四种类型之一。 Microsoft.Data.Sqlite 支持其他 .NET 类型,但最终强制这些值在这些类型和四种基元类型中的一种类型之间进行转换。
.NET | SQLite | 备注 |
---|---|---|
Boolean | INTEGER | 0 或 1 |
Byte | INTEGER | |
Byte[] | BLOB | |
Char | TEXT | UTF-8 |
DateOnly | TEXT | yyyy-MM-dd |
DateTime | TEXT | yyyy-MM-dd HH:mm:ss.FFFFFFF |
DateTimeOffset | TEXT | yyyy-MM-dd HH:mm:ss.FFFFFFFzzz |
十进制 | TEXT | 0.0########################### 格式。 REAL 将有损。 |
Double | real | |
GUID | TEXT | 00000000-0000-0000-0000-000000000000 |
Int16 | INTEGER | |
Int32 | INTEGER | |
Int64 | INTEGER | |
SByte | INTEGER | |
Single | real | |
String | TEXT | UTF-8 |
TimeOnly | TEXT | HH:mm:ss.fffffff |
TimeSpan | TEXT | d.hh:mm:ss.fffffff |
UInt16 | INTEGER | |
UInt32 | INTEGER | |
UInt64 | INTEGER | 大值溢出 |
某些 .NET 类型可以从替代 SQLite 类型中读取。 还可以将参数配置为使用这些替代类型。
.NET | SQLite | 备注 |
---|---|---|
Char | INTEGER | UTF-16 |
DateOnly | real | 儒略日值 |
DateTime | real | 儒略日值 |
DateTimeOffset | real | 儒略日值 |
GUID | BLOB | |
TimeOnly | real | 以天为单位 |
TimeSpan | real | 以天为单位 |
例如,下面的查询从结果集的 REAL 列中读取 TimeSpan 值。
command.CommandText =
@"
SELECT name, julianday(finished) - julianday(started) AS length
FROM task
WHERE finished IS NOT NULL
";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var name = reader.GetString(0);
var length = reader.GetTimeSpan(1);
Console.WriteLine($"'{name}' took {length}.");
}
}
您可以通过以下两种方法释放 System.Threading.Timer 对象:
1. 等待 Timer 处理完当前的工作并释放资源
在 Timer
对象的回调方法中,您可以调用 Timer.Change
方法来更改定时器的参数,例如将定时器的 dueTime 和 period 设置为 Timeout.Infinite
,以强制定时器停止。这样,当定时器的回调方法执行完成后,系统会自动释放相应的资源。以下是一个示例代码:
using System;
using System.Threading;
class Program
{
static void Main(string[] args)
{
// 创建一个新的 Timer 对象,每隔 1 秒执行一次回调方法
Timer timer = new Timer(
(state) => Console.WriteLine("定时器执行了一次。"),
null,
TimeSpan.FromSeconds(0),
TimeSpan.FromSeconds(1));
Console.ReadLine();
// 在回调方法中更改定时器参数,以强制停止定时器并释放资源
timer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
}
}
2. 手动释放 Timer 对象
如果您需要在定时器执行之前或之后立即释放其资源,可以调用 Timer.Dispose 方法手动释放 Timer 对象。以下是一个示例代码:
using System;
using System.Threading;
class Program
{
static void Main(string[] args)
{
// 创建一个新的 Timer 对象,每隔 1 秒执行一次回调方法
Timer timer = new Timer(
(state) => Console.WriteLine("定时器执行了一次。"),
null,
TimeSpan.FromSeconds(0),
TimeSpan.FromSeconds(1));
Console.ReadLine();
// 手动调用 Dispose 方法释放 Timer 对象
timer.Dispose();
}
}
注意,如果您选择手动释放 Timer 对象,应确保在回调方法已经完成后才释放 Timer 对象,否则会导致回调方法访问已释放的对象并引发异常。
希望这些提示可以帮助您释放 System.Threading.Timer 对象。
在 C# 中,您可以通过将 Task 的 TaskCreationOptions 设置为 TaskCreationOptions.LongRunning 或 TaskCreationOptions.RunContinuationsAsynchronously,以指示将任务分配给新的线程或线程池并在后台运行。
以下是使用 TaskCreationOptions.LongRunning 方式实现后台执行的示例代码:
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main(string[] args)
{
// 使用 TaskCreationOptions.LongRunning 创建一个后台执行的 Task 对象
Task task = Task.Factory.StartNew(
() =>
{
Console.WriteLine("开始执行任务...");
Thread.Sleep(5000);
Console.WriteLine("任务执行完毕。");
},
CancellationToken.None,
TaskCreationOptions.LongRunning,
TaskScheduler.Default);
Console.WriteLine("主线程继续执行...");
Console.ReadLine();
}
}
在上述代码中,我们使用 Task.Factory.StartNew 方法创建了一个后台执行的 Task 对象,并通过 TaskCreationOptions.LongRunning 选项指示分配给新的线程执行。任务执行时将休眠 5 秒,以模拟执行长时间任务的情况。
另外,使用 TaskCreationOptions.RunContinuationsAsynchronously 选项也可以实现后台执行,例如:
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
// 使用 TaskCreationOptions.RunContinuationsAsynchronously 创建一个后台执行的 Task 对象
Task task = Task.Run(async () =>
{
Console.WriteLine("开始执行任务...");
await Task.Delay(5000);
Console.WriteLine("任务执行完毕。");
}, TaskCreationOptions.RunContinuationsAsynchronously);
Console.WriteLine("主线程继续执行...");
Console.ReadLine();
}
}
希望这些示例代码可以帮助您实现 C# Task 后台执行。
以下是一个示例的Dockerfile,用于构建.NET Core 7.0应用程序的容器:
# 设置基础镜像
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build-env
WORKDIR /app
# 复制应用程序项目并生成
COPY *.csproj ./
RUN dotnet restore
COPY . ./
RUN dotnet publish -c Release -o out
# 使用最新的microsoft/dotnet镜像
FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "MyApp.dll"]
Dockerfile将基础镜像设置为.NET Core 7.0 SDK,并在其中构建应用程序。然后它使用最新的.NET Core 7.0运行时映像作为基础镜像。最后,将生成的应用程序复制到容器中并设置entrypoint以运行该应用程序。
以下示例演示如何使用 TransactionScope 类定义代码块以参与事务。
C#
复制
// This function takes arguments for 2 connection strings and commands to create a transaction
// involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the
// transaction is rolled back. To test this code, you can connect to two different databases
// on the same server by altering the connection string, or to another 3rd party RDBMS by
// altering the code in the connection2 code block.
static public int CreateTransactionScope(
string connectString1, string connectString2,
string commandText1, string commandText2)
{
// Initialize the return value to zero and create a StringWriter to display results.
int returnValue = 0;
System.IO.StringWriter writer = new System.IO.StringWriter();
try
{
// Create the TransactionScope to execute the commands, guaranteeing
// that both commands can commit or roll back as a single unit of work.
using (TransactionScope scope = new TransactionScope())
{
using (SqlConnection connection1 = new SqlConnection(connectString1))
{
// Opening the connection automatically enlists it in the
// TransactionScope as a lightweight transaction.
connection1.Open();
// Create the SqlCommand object and execute the first command.
SqlCommand command1 = new SqlCommand(commandText1, connection1);
returnValue = command1.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command1: {0}", returnValue);
// If you get here, this means that command1 succeeded. By nesting
// the using block for connection2 inside that of connection1, you
// conserve server and network resources as connection2 is opened
// only when there is a chance that the transaction can commit.
using (SqlConnection connection2 = new SqlConnection(connectString2))
{
// The transaction is escalated to a full distributed
// transaction when connection2 is opened.
connection2.Open();
// Execute the second command in the second database.
returnValue = 0;
SqlCommand command2 = new SqlCommand(commandText2, connection2);
returnValue = command2.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command2: {0}", returnValue);
}
}
// The Complete method commits the transaction. If an exception has been thrown,
// Complete is not called and the transaction is rolled back.
scope.Complete();
}
}
catch (TransactionAbortedException ex)
{
writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message);
}
// Display messages.
Console.WriteLine(writer.ToString());
return returnValue;
}
如果确信范围内的所有操作都已成功完成,则只应调用此方法一次,以通知事务管理器所有资源的状态都是一致的,并且可以提交事务。 最好将调用作为块中的 using
最后一个语句。
未能调用此方法会中止事务,因为事务管理器将此解释为系统故障或在事务范围内引发的异常。 但是,还应注意,调用此方法并不能保证事务的提交。 它只是一种将状态通知给事务管理器的方式。 调用此方法后,无法再通过 Current
属性访问环境事务,并且尝试这样做会导致引发异常。
如果 TransactionScope
对象创建了事务,则资源管理器之间的实际提交工作将发生在 End Using
语句中。 如果该对象未创建事务,则每当 Commit
对象的所有者调用 CommittableTransaction
时都会执行提交。 此时,事务管理器会调用资源管理器,并根据是否在 对象上 TransactionScope
调用此方法来通知它们提交或回滚。
解码:
public static string UnBase64String(string value)
{
if (value == null || value == "")
{
return "";
}
byte[] bytes = Convert.FromBase64String(value);
return Encoding.UTF8.GetString(bytes);
}
编码:
public static string ToBase64String(string value)
{
if (value == null || value == "")
{
return "";
}
byte[] bytes = Encoding.UTF8.GetBytes(value);
return Convert.ToBase64String(bytes);
}
昨天在 github 上准备找找 C# 9 又有哪些新语法糖可以试用,不觉在一个文档上看到一个很奇怪的写法: foreach (var item in myArray[0..5]) 哈哈,熟悉又陌生,玩过python的朋友对这个 [0..5] 太熟悉不过了,居然在 C# 中也遇到了,开心哈,看了下是 C# 8 的新语法,讽刺讽刺,8 都没玩熟就搞 9 了,我的探索欲比较强,总想看看这玩意底层是由什么支撑的。
从前面介绍的 myArray[0..5] 语义上也能看出,这是一个切分array的操作,那到底有几种切分方式呢? 下面一个一个来介绍,为了方便演示,我先定义一个数组,代码如下:
var myarr = new string[] { "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
如果用 linq 的话,可以用 Take(3),用切片操作的话就是 [0..3], 代码如下:
static void Main(string[] args)
{
var myarr = new string[] { "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
//1. 获取数组 前3个元素
var query1 = myarr[0..3];
var query2 = myarr.Take(3).ToList();
Console.WriteLine($"query1={string.Join(",", query1)}");
Console.WriteLine($"query2={string.Join(",", query2)}");
}
这个怎么提取呢?在 python 中直接用 -3 表示就可以了,在C# 中需要用 ^ 来表示从末尾开始,代码如下:
static void Main(string[] args)
{
var myarr = new string[] { "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
//1. 获取数组 最后3个元素
var query1 = myarr[^3..];
var query2 = myarr.Skip(myarr.Length - 3).ToList();
Console.WriteLine($"query1={string.Join(",", query1)}");
Console.WriteLine($"query2={string.Join(",", query2)}");
}
用 linq 的话,就需要使用 Skip + Take
双组合,如果用切片操作的话就太简单了。。。
static void Main(string[] args)
{
var myarr = new string[] { "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
//1. 获取数组 中 index=4,5,6 三个位置的元素
var query1 = myarr[4..7];
var query2 = myarr.Skip(4).Take(3).ToList();
Console.WriteLine($"query1={string.Join(",", query1)}");
Console.WriteLine($"query2={string.Join(",", query2)}");
}
从上面的切割区间 [4..7]
的输出结果来看,这是一个 左闭右开
的区间,所以要特别注意一下。
从要求上来看就是获取元素 80 和 90,如果你理解了前面的两个用法,我相信这个你会很快的写出来,代码如下:
static void Main(string[] args)
{
var myarr = new string[] { "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
//1. 获取 array 中倒数第三和第二个元素
var query1 = myarr[^3..^1];
var query2 = myarr.Skip(myarr.Length - 3).Take(2).ToList();
Console.WriteLine($"query1={string.Join(",", query1)}");
Console.WriteLine($"query2={string.Join(",", query2)}");
}
通过前面 4 个例子,我想大家都知道怎么玩了,接下来就是看看到底内部是用什么做支撑的,这里使用 DnSpy 去挖挖看。
用 dnspy 反编译代码如下:
//编译前
var query1 = myarr[0..3];
//编译后:
string[] query = RuntimeHelpers.GetSubArray<string>(myarr, new Range(0, 3));
从编译后的代码可以看出,原来获取切片的 array 是调用 RuntimeHelpers.GetSubArray
得到了,然后我简化一下这个方法,代码如下:
public static T[] GetSubArray<[Nullable(2)] T>(T[] array, Range range)
{
ValueTuple<int, int> offsetAndLength = range.GetOffsetAndLength(array.Length);
int item = offsetAndLength.Item1;
int item2 = offsetAndLength.Item2;
T[] array3 = new T[item2];
Buffer.Memmove<T>(Unsafe.As<byte, T>(array3.GetRawSzArrayData()), Unsafe.Add<T>(Unsafe.As<byte, T>(array.GetRawSzArrayData()), item), (ulong)item2);
return array3;
}
从上面代码可以看到,最后的 子array 是由 Buffer.Memmove
完成的,但是给 子array 的切割位置是由 GetOffsetAndLength
方法实现,继续追一下代码:
public readonly struct Range : IEquatable<Range>
{
public Index Start { get; }
public Index End { get; }
public Range(Index start, Index end)
{
this.Start = start;
this.End = end;
}
public ValueTuple<int, int> GetOffsetAndLength(int length)
{
Index start = this.Start;
int num;
if (start.IsFromEnd)
{
num = length - start.Value;
}
else
{
num = start.Value;
}
Index end = this.End;
int num2;
if (end.IsFromEnd)
{
num2 = length - end.Value;
}
else
{
num2 = end.Value;
}
return new ValueTuple<int, int>(num, num2 - num);
}
}
看完上面的代码,你可能有两点疑惑:
1) start.IsFromEnd 和 end.IsFromEnd 是什么意思。
其实看完上面代码逻辑,你就明白了,IsFromEnd 表示起始点是从左开始还是从右边开始,就这么简单。
2) 我并没有看到 start.IsFromEnd 和 end.IsFromEnd 是怎么赋上值的。
在 Index 类的构造函数中,取决于上一层怎么去 new Index 的时候塞入的 true 或者 false,如下代码:
这个例子的流程大概是: new Range(1,3) -> operator Index(int value) -> FromStart(value) -> new Index(value)
,可以看到最后在 new 的时候并没有对可选参数赋值。
刚才的例子是没有对可选参数赋值,那看看本例是不是 new Index 的时候赋值了?
//编译前:
var query1 = myarr[^3..];
//编译后:
string[] query = RuntimeHelpers.GetSubArray<string>(myarr, Range.StartAt(new Index(3, true)));
看到没有,这一次 new Index 的时候,给了 IsFromEnd = true , 表示从末尾开始计算,大家再结合刚才的 GetOffsetAndLength 方法,我想这逻辑你应该理顺了吧。
四:总结
总的来说这个切片操作太实用了,作用于 arr 可以大幅度减少对 skip & take 的使用,作用于 string 也可以大幅减少 SubString 的使用,如:”12345″[1..3] -> “12345”.Substring(1, 2),嘿嘿,厉害了吧! 还是C# 大法🐂👃
Skip,Take:
list = list.Skip(pageNum * pageSize).Take(pageSize).ToList();
pageSize :表示一页多少条。
pageNum:表示页数,但是正确的页数是pageNum + 1。因为pageNum = 0,是第一页。pageNum = 1的时候,是第二页。
Skip :表示从第pageNum * pageSize + 1条数据开始,也就是说再这之前有pageNum * pageSize条数据。
Take:表示显示多少条数据,也就是pageSize条。
list = list.Skip(5 * 2).Take(2).ToList();
pageNum * pageSize = 10,那么之前已经有10条数据。从第11条数据开始查询。查询2条。这就是第6页显示的内容。
C#控制台程序代码:
class Program
{
static int Main()
{
//每页条数
const int pageSize = 2;
//页码 0也就是第一条
int pageNum = 0;
//源数据
string[] names = { "刘一","陈二","张三","李四","王五","赵六","孙七","周八","吴九" };
while (pageNum * pageSize < names.Length)
{
//分页
var query = names.Skip(pageNum * pageSize).Take(pageSize);
Console.WriteLine("输出第{0}页记录", pageNum + 1);
//输出每页内容
foreach (var q in query)
{
Console.WriteLine(q);
}
pageNum++;
}
Console.ReadKey();
return 0;
}
}
结果: