Pomelo.entityframeworkcore.mysql: TimeSpan प्रकार TIME MySQL प्रकार के लिए सही ढंग से मैप नहीं करता है

मान रूपांतरण पर एक नज़र डालें, विशेष रूप से TimeSpanToStringConverter और TimeSpanToTicksConverter यदि आपको एक महीने से अधिक समय की आवश्यकता है।

@mguinness टिप के लिए धन्यवाद। क्या मैं टाइमपैन कनवर्टर को टिक्स की संख्या में अनुवादित करने के रूप में व्याख्या करने में सही हूं, जो कि डेटाबेस में एक लंबा है?
इसके अलावा अगर आप कुछ नहीं कर सकते हैं तो मैं बग रिपोर्ट बंद कर दूंगा।

TimeSpan प्रकार एक TIME टाइप किया गया कॉलम बनाता है जिसमें TimeSpan की तुलना में छोटी बाधा होती है। विशेष रूप से TIME केवल '-838:59:59.000000' से '838:59:59.000000' तक जाता है। जबकि TimeSpan 256204778:48:05.477580 तक पहुंच सकता है।

यह अपेक्षित है। वर्तमान में हम TimeSpan को 24 घंटे से छोटे मान के रूप में संभालते हैं। तो new TimeSpan(1, 0, 0, 0) भी काम नहीं करेगा। यह SQL सर्वर के व्यवहार की नकल करता है।

जैसा कि @mguinness ने बताया, TimeSpanToTicksConverter का उपयोग करना यहां जाने का तरीका है। इसे इस तरह इस्तेमाल किया जा सकता है:

```सी#
entity.Property(e => e.BestServedBefore)
.HasColumnType("bigint")
.HasConversion (नया TimeSpanToTicksConverter ());

It is equivalent to the following code:

```c#
entity.Property(e => e.BestServedBefore)
    .HasColumnType("bigint")
    .HasConversion(v => v.Ticks, v => new TimeSpan(v));

यहाँ एक पूरी तरह कार्यात्मक उदाहरण है:

```सी#
सिस्टम का उपयोग करना;
System.Diagnostics का उपयोग करना;
System.Linq का उपयोग करना;
Microsoft.EntityFrameworkCore का उपयोग करना;
Microsoft.EntityFrameworkCore.Storage.ValueConversion का उपयोग करना;
Microsoft.Extensions.Logging का उपयोग करना;
Pomelo.EntityFrameworkCore.MySql.Infrastructure का उपयोग करना;
Pomelo.EntityFrameworkCore.MySql.Storage का उपयोग करना;

नेमस्पेस इश्यूकंसोलटेम्पलेट
{
पब्लिक क्लास आइसक्रीम
{
सार्वजनिक int IceCreamId { प्राप्त करें; सेट; }
सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; सेट; }
पब्लिक टाइमस्पेन बेस्टसर्वेड बिफोर {प्राप्त करें; सेट; }
}

public class Context : DbContext
{
    public DbSet<IceCream> IceCreams { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder
            .UseMySql(
                "server=127.0.0.1;port=3306;user=root;password=;database=Issue1046",
                b => b
                    .ServerVersion(new ServerVersion("8.0.20-mysql"))
                    .CharSetBehavior(CharSetBehavior.NeverAppend))
            .UseLoggerFactory(
                LoggerFactory.Create(
                    b => b
                        .AddConsole()
                        .AddFilter(level => level >= LogLevel.Information)))
            .EnableSensitiveDataLogging()
            .EnableDetailedErrors();
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<IceCream>(
            entity =>
            {
                entity.Property(e => e.BestServedBefore)
                    .HasColumnType("bigint")
                    .HasConversion(new TimeSpanToTicksConverter());

                entity.HasData(
                    new IceCream
                    {
                        IceCreamId = 1,
                        Name = "Vanilla",
                        BestServedBefore = new TimeSpan(0, 12, 0, 0)
                    },
                    new IceCream
                    {
                        IceCreamId = 2,
                        Name = "Chocolate",
                        BestServedBefore = new TimeSpan(0, 23, 59, 59)
                    },
                    new IceCream
                    {
                        IceCreamId = 3,
                        Name = "Artificial Vanilla",

                        // This will not work out-of-the box.
                        // Usage of a converter is necessary.
                        BestServedBefore = new TimeSpan(42, 11, 0, 0)
                    }
                );
            });
    }
}

internal class Program
{
    private static void Main()
    {
        using var context = new Context();

        context.Database.EnsureDeleted();
        context.Database.EnsureCreated();

        var iceCreams = context.IceCreams
            .OrderBy(i => i.IceCreamId)
            .ToList();

        Debug.Assert(iceCreams.Count == 3);
        Debug.Assert(iceCreams[0].BestServedBefore == new TimeSpan(0, 12, 0, 0));
        Debug.Assert(iceCreams[1].BestServedBefore == new TimeSpan(0, 23, 59, 59));
        Debug.Assert(iceCreams[2].BestServedBefore == new TimeSpan(42, 11, 0, 0));
    }
}

}
```