问题[c#](coding)

我正在深入研究反射和指针，遇到了一个有趣的挑战。假设你有以下类：

namespace Foobar
{
    internal class Foo()
    {
        internal static readonly Me = new Foo();
    }
}

我可以使用以下命令轻松获取该字段的值：

Assembly a = Assembly.Load("AssemblyWithFoo");
Type t = a.GetType("Foobar.Foo");
FieldInfo fi = t.GetRuntimeFields().First(f => f is { Name: "Me", IsStatic: true });
var bar = fi.GetValue(null);

但是不允许为其设置新值，因为readonly“代码访问安全”已经过时了。

fi.SetValue(null, new Foo());

因此我考虑使用指针来unsafe改变这个字段：

var foo = GetFooFromAssembly();
var bar = fi.GetValue(null);
unsafe
{
    object* ptr = &bar;
    *ptr = foo;
}

这样做的原因是它将bar变量更改为包含foo，但不会更改字段，因为bar变量是静态字段的“副本”，而不是字段本身。

有没有办法获取指向静态只读字段的指针并在其中设置一个新对象？

源代码ConcurrentDictionary提到了使用的可能性TAlternateKey，这是一个 ref 结构。https ://github.com/dotnet/runtime/blob/main/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs

另外，经过一番搜索，我还发现了其他有趣的例子。例如： https ://github.com/dotnet/runtime/blob/main/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif
//...
#if NET9_0_OR_GREATER
            internal bool TryGetValue(ReadOnlySpan<char> key, [NotNullWhen(true)] out CacheEntry? entry)
                => _stringAltLookup.TryGetValue(key, out entry);
#endif

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif

为了获得更好的性能，我是否应该使用ReadOnlySpan<char>作为 Key，而ConcurrentDictionary不是string？

我正在尝试使用 JWT（不带 cookie）在我的 ASP.NET Core 8 API 中实现 Google 身份验证，但我一直收到此错误：

InvalidOperationException：为方案“Bearer”注册的身份验证处理程序是“JwtBearerHandler”，无法用于 SignInAsync。您是否忘记调用 AddAuthentication().AddCookie("Cookies") 和 SignInAsync("Cookies",...)？

这是我的代码：

Program.cs：

var key = Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Secret"]);
builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = GoogleDefaults.AuthenticationScheme;
})
.AddGoogle(options =>
{
    var googleAuth = builder.Configuration.GetSection("GoogleAuth");
    options.ClientId = googleAuth["ClientId"];
    options.ClientSecret = googleAuth["ClientSecret"];
    options.CallbackPath = "/auth/signin-google";
    options.SaveTokens = true;
})
.AddJwtBearer(options =>
{
    options.SaveToken = true;
    options.TokenValidationParameters = new TokenValidationParameters
    {
        // Validation parameters...
    };
});

控制器：

[HttpGet("login")]
public IActionResult Login()
{
    var redirectUrl = Url.Action(nameof(GoogleResponse),"Auth");
    var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
    return Challenge(properties, GoogleDefaults.AuthenticationScheme);
}

[HttpGet("signin-google")]
public async Task<IActionResult> GoogleResponse()
{
    // Error occurs here...
    var result = await HttpContext.AuthenticateAsync(GoogleDefaults.AuthenticationScheme);
}

我正在使用 EF Core v9.0.3 和 WPF。如何让实体检测其数据何时从数据库加载？

List<>当它从数据库接收数据时，我想从分隔的字符串属性填充实体上未映射的代理。

构造函数太早，PropertyChanged当数据从数据库加载到属性中时不会触发。

当代理列表绑定到 UI 时，字符串属性尚未填充，因此我无法在其获取中创建列表。

PopulateFKLookupsUI()下面的例子。显然，一旦数据上下文创建了实体，我就可以从视图模型中调用，但我希望实体能够处理它。

public class PretendEntityWithProxyCollection : FwObservableObject
{
    public PretendEntityWithProxyCollection() 
    {
        FKLookupsUI.CollectionChanged += FKLookupsUI_CollectionChanged;
        FKLookupsUI.ItemPropertyChanged += FKLookupsUI_ItemPropertyChanged;
    }

    private string? _fKLookups;

    [Browsable(false)]
    public string? FKLookups
    {
        get { return _fKLookups; }
        set { CheckPropertyChanged(ref _fKLookups, value); }
    }

    [NotMapped]
    public FwObservableItemCollection<FKLookup> FKLookupsUI { get; set; } = [];

    #region Private Methods

    private void FKLookupsUI_ItemPropertyChanged(object? sender, PropertyChangedEventArgs e)
    {
        UpdateFKLookups();
    }

    private void FKLookupsUI_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        UpdateFKLookups();
    }

    private void UpdateFKLookups()
    {
        if (!populating)
        {
            List<string> fkLookupsArray = [];

            foreach (var item in FKLookupsUI.Where(x => x.Deleted == false))
            {
                fkLookupsArray.Add(item.ToString());
            }

            FKLookups = string.Join(":", fkLookupsArray);
        }
    }

    private bool populating;

    public void PopulateFKLookupsUI()
    {
        populating = true;

        foreach (var item in FKLookups.Split(':', StringSplitOptions.RemoveEmptyEntries))
        {
            FKLookupsUI.Add(new FKLookup() { ForeignKey = item });
        }

        populating = false;
    }

    #endregion //Private Methods
}

我在 Google 上搜索，也查看了类似的问题，但就是找不到明确的答案。我的问题是，所有关于阻塞收集的示例似乎都没有考虑长时间运行或异步的情况。如果这个问题已经有人回答了，我很抱歉，但我没有找到任何可以解释的答案。

我会有一个队列，BlockingCollection用于存放待处理的任务。这些任务的处理速度可能很快，也可能需要几分钟。但我需要一个能够阻塞队列BlockingCollection并在整个进程生命周期内都保持活跃的机制。我一直在尝试改进我处理任务的方式，这导致我把这个Process方法变成了异步的。后来我开始参与“StartNew Bad”的讨论，而我得到的反馈似乎并不完整。

这是我正在做的事情的一个例子。

private BlockingCollection<Job> _queue;

void Main()
{
    var cts = new CancellationTokenSource();
    var ct = cts.Token;
    _queue = new BlockingCollection<Job>();
    
    // Simulate the addition of Jobs
    Task.Run(() => { while (!ct.IsCancellationRequested) { _queue.Add(new Job()); Thread.Sleep(1000); }});
    
    // Start the processing ta... thr... whatever
    Task.Factory.StartNew(() => ProcessJobs(ct), TaskCreationOptions.LongRunning);
    
    Console.Read();
    cts.Cancel();
    _queue.CompleteAdding();
}


private async Task ProcessJobs(CancellationToken ct)
{
    foreach (var job in _queue.GetConsumingEnumerable(ct))
    {
        try 
        {
            var result = await job.Process();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.WriteLine("Job Processed.");
    }
}

public class Job
{
    public async Task<bool> Process()
    {
        // await network communication
        await Task.Run(() => Thread.Sleep(100));
        return true;
    }
}

我担心的是，我一直在阅读Task.Factory.StartNew异步方法的奇怪行为，例如，也许你的代码的第一部分在它为其创建的任何内容上运行，但是一旦你点击 await，当你回来时，你只会在从中提取的任何内容上ThreadPool。你应该使用Task.Run。

所以我的问题是我应该如何执行ProcessJobs？保留StartNew？？？Task.Runnew Thread(ProcessJobs)

ProcessJobs需要在应用的整个生命周期内持续执行。只有CompleteAdding()在应用关闭时，它才会被取消并加入队列。此处理是应用的主要功能。虽然可能存在没有作业添加的时间段，但很可能存在 process 方法无需等待新项目添加的时间段。

我们目前仅限于 .net 4.7.2，如果有必要的话，我们可能会转向 4.8。

提前致谢。

更新：我不是在问异步阻塞集合；那个问题没有任何帮助。我问的Thread是Task.Run、 或Task.Factory.StartNew。即使我使用“有没有类似异步 BlockingCollection<T> 的东西？”中的任何建议，我仍然需要一个可以在等待输入时被阻塞的Thread或Task。当我说这个处理是主要功能时，我并不是说它是唯一的功能，并且整个过程都可能被阻塞。

更新：好的，我想我现在明白了。我之前把新旧概念搞混了。我不明白为什么我问线程的时候，他们让我使用不同的队列机制。所以，这里修改了上面的代码，去掉了阻塞，直接创建Thread或Task。

private Channel<Job> _queue;

void Main()
{
    var cts = new CancellationTokenSource();
    var ct = cts.Token;
    _queue = Channel.CreateBounded<Job>(100);
    
    // Simulate the addition of Jobs
    Task.Run(async () => { while (!ct.IsCancellationRequested) { await _queue.Writer.WriteAsync(new Job(), ct); Thread.Sleep(1000); }});
    
    var processingTask = ProcessJobs(ct);
    
    Console.Read();
    cts.Cancel();
    _queue.Writer.TryComplete();
    // Consider checking the state of processingTask, waiting for it to finish?
}

private async Task ProcessJobs(CancellationToken ct)
{
    while (!ct.IsCancellationRequested)
    {
        try 
        {
            var job = await _queue.Reader.ReadAsync(ct);
            await job.Process();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.WriteLine("Job Processed.");
    }
}

public class Job
{
    public async Task<bool> Process()
    {
        // await network communication
        await Task.Run(() => Thread.Sleep(100));
        return true;
    }
}

再次感谢您的帮助。

我有多个不同的类，它们具有不同的字段和属性。但是，所有类都有一个共同的字段private Boolean isShown，即 ，它表示该类是否应该显示。在所有具有 的类中isShown，任何给定时间只能有一个isShown。true也可能没有任何类设置isShown为true。在我的主程序中，每个类都有一个对象。我希望有一个方法可以找到设置为 的对象isShown（true如果有），然后返回它，但我不知道该怎么做。

我有两个模型：

public class HouseDto 
{
    public DateTime[] ProductionDates { get; set; }
}

和

public class House
{
    public string PeriodStart { get; set; }
    
    public string PeriodEnd { get; set; }
}

我想将PeriodStart和PeriodEnd合并成一个数组ProductionDates。像这样：

CreateMap<HouseDto, House>()
    .ForMember(d => d.ProductionDates, e => e.MapFrom(s => s.PeriodStart))
    .ForMember(d => d.ProductionDates, e => e.MapFrom(s => s.PeriodEnd));

问题在于PeriodStart会覆盖PeriodEnd。我查看了文档，也用 Stack Overflow 查了一下，但还没找到将多个数组合并成一个数组的方法。AutoMapper 能实现吗？

运行 NbLinksExpirationStatus 大约需要 12 秒，这对于我想要实现的目标来说不够快。这可能是 Contains() 的问题吗？有什么方法可以让它执行得更快吗？我正在使用 EF6 和 SQL Server。请问我在这种情况下是否最好直接使用 sqlquery？

笔记 ：

HashSet<int> oneEntitiesPerimeter = oneEquipment.Select(x => x.ID_ONE).ToHashSet();
HashSet<int> twoEntitiesPerimeter = twoEquipment.Select(x => x.ID_TWO).ToHashSet();

存在查询的方法：

public static Tuple<int, int> NbLinksExpirationStatus(HashSet<int> oneEntitiesPerimeter, HashSet<int> twoEntitiesPerimeter)
{
    using (DbEntities context = new DbEntities())
    {
        int aboutToExpireValue = Constants.LinkStatusAboutToExpire; #1
        int expiredValue = Constants.LinkStatusExpired; #2

        var oneIds = oneEntitiesPerimeter ?? new HashSet<int>();
        var twoIds = twoEntitiesPerimeter ?? new HashSet<int>();

        var joinedQuery = (from t in context.ONE_DISTRIBUTION_STATUS
                            join o in context.TWO_DISTRIBUTION_STATUS on t.ID_ent equals o.ID_ent into joined
                            from o in joined.DefaultIfEmpty()
                            where oneIds.Contains(t.ID_ONE) && (o == null || twoIds.Contains(o.ID_TWO))
                            select new { oneExpirationStatus = t.LINK_STATUS_EXPIRATION, twoExpirationStatus = o.LINK_STATUS_EXPIRATION }).ToList();

        var aboutToExpireCount = joinedQuery.Where(j =>
            j.oneExpirationStatus == aboutToExpireValue || j.twoExpirationStatus == aboutToExpireValue).Count();

        var expiredCount = joinedQuery.Where(j =>
            j.oneExpirationStatus == expiredValue || j.twoExpirationStatus == expiredValue).Count();

        return new Tuple<int, int>(aboutToExpireCount, expiredCount);
    }
}

编辑：我尝试过改用 SQL，但执行速度始终没有提升。以下是尝试方法：

string oneIds = "NULL";            
if(oneEntitiesPerimeter != null && oneEntitiesPerimeter.Count > 0)
{
    oneIds = string.Join(",", oneEntitiesPerimeter);
}
string twoIds = "NULL";
if (twoEntitiesPerimeter != null && twoEntitiesPerimeter.Count > 0)
{
    twoIds = string.Join(",", twoEntitiesPerimeter);
}

string sqlQuery = "SELECT " +
    "COALESCE(SUM(CASE WHEN t.LINK_STATUS_EXPIRATION = " + aboutToExpireValue + " OR COALESCE(o.LINK_STATUS_EXPIRATION, '')= " + aboutToExpireValue + " THEN 1 ELSE 0 END), 0) AS AboutToExpire," +
    "COALESCE(SUM(CASE WHEN t.LINK_STATUS_EXPIRATION = " + expiredValue + " OR COALESCE(o.LINK_STATUS_EXPIRATION, '') = " + expiredValue + " THEN 1 ELSE 0 END), 0) AS Expired "+
    "FROM ONE_DISTRIBUTION_STATUS t LEFT JOIN TWO_DISTRIBUTION_STATUS o ON t.ID_ent = o.ID_ent WHERE t.ID_ONE in (" + oneIds + ") AND (o.ID_TWO in (" + twoIds + ") OR o.ID_TWO IS NULL)";

var counter = context.Database.SqlQuery<LinkExpirationStatusWidget>(sqlQuery).FirstOrDefault();           
result = new Tuple<int, int>(counter.AboutToExpire, counter.Expired);

添加用于存储结果的类：

public class LinkExpirationStatusWidget
{
    /// <summary>
    /// Gets or sets count of links about to expire
    /// </summary>
    /// <value>About To Expire count</value>
    public int AboutToExpire { get; set; }

    /// <summary>
    /// Gets or sets count of links expired
    /// </summary>
    /// <value>Expired count</value>
    public int Expired { get; set; }
}

在 Visual Studio 2022（或任何版本）中，如果使用 string.IsNullOrWhiteSpace 检查是否为空，C# 编译器不会显示绿色波浪警告。但如果使用字符串扩展方法，则会显示绿色警告。

有什么方法可以让 C# 编译器不显示警告吗？或者如何标记扩展方法使其行为与 string.IsNullOrWhiteSpace 相同？

我有一个包含两个物品的列表（名称和描述），我需要清点这些物品的数量。我已经成功清点了物品数量，但找不到列出描述的方法。我想要一个包含名称、数量和描述的列表。

public void GetList()
{
    // A twi items list, Count items required, print list.

    List<(string Name, string Description)> itemlist = new List<(string Name, string Description)>();

    itemlist.Add(("Apple", "ABCDED"));
    itemlist.Add(("Pear", "KLMAN"));
    itemlist.Add(("Apple", "ABCDED"));
    itemlist.Add(("Peach", "EFGHI"));
    itemlist.Add(("Apple", "ABCDED"));
    itemlist.Add(("Peach", "EFGHI"));
    itemlist.Add(("Apple", "ABCDED"));
    itemlist.Add(("Banana", "MNOPQ"));
    itemlist.Add(("Cherry", "PQRST"));
    itemlist.Add(("Peach", "EFGHI"));
    itemlist.Add(("Banana", "MNOPQ"));
    itemlist.Add(("Pear", "KLMAN"));
    itemlist.Add(("Apple", "ABCDED"));


    var newlist = itemlist.GroupBy(i => i.Name).Select(group => new { Name = group.Key, count = group.Count().ToString() }).ToList();


    foreach (var item in newlist)
    {
        Debug.Print(string.Format("{0} {1}", item.Name, item.count.ToString()));
    }

}