C# 在将数据插入数据库之前检查sqlite网络中是否存在数据

我正在制作一个Xamarin.Android应用程序，它将使用“模板”，模板如下：

[Table("Templates")]
    public class Template
    {
        [PrimaryKey, AutoIncrement]
        public int Id { get; set; }
        public int Category { get; set; }
        //[TextBlob("imagesBlobbed")]
        [OneToMany, Unique]
        public List<TemplateImage> TemplateImages { get; set; }
        public string ImagesHash { get; set; }
        //public string imagesBlobbed { get; set; }
    }
    [Table("TemplateImages")]
    public class TemplateImage
    {
        [PrimaryKey, AutoIncrement]
        public int Id { get; set; }
        public int Category { get; set; }
        public string ImagesHash { get; set; }
        public int Image { get; set; }
        [ForeignKey(typeof(Template))]
        public int TemplateId { get; set; }
    }

[表格（“模板”）]
公共类模板
{
[主密钥，自动增量]
公共int Id{get；set；}
公共int类{get；set；}
//[TextBlob（“imagesBlobbed”）]
[一家公司，独一无二]
公共列表模板图像{get；set；}
公共字符串ImagesHash{get；set；}
//公共字符串imagesBlobbed{get；set；}
}
[表（“模板图像”）]
公共类模板映像
{
[主密钥，自动增量]
公共int Id{get；set；}
公共int类{get；set；}
公共字符串ImagesHash{get；set；}
公共int映像{get；set；}
[外键（模板类型））]
public int TemplateId{get；set；}
}

我希望所有TemplateImages对象在我的数据库中都是唯一的，属性unique不起任何作用，因为我猜因为TemplateImageTable有一个自动递增Id，所以无论两个记录中的图像或ImageHash是否相同，它都将始终是唯一的

我当时在想，还有什么方法可以确保模板图像是唯一的（注意：当我说唯一时，我的意思是没有任何其他列表以相同的顺序为每个模板图像提供准确的图像）

此外，我还使用了图像的ResourceID作为图像，这是错误的，因为它们可能会在每次新编译的应用程序更新时发生更改

所以我决定从这些图像中创建一个哈希md5。在Xamarin.Android中加载资源图像（我的图像是vector.xml文件）的唯一方法是将资源转换为位图，然后将位图转换为字节，然后将字节转换为md5

我也应该有一个用于模板项的哈希字符串。因此，我正在为模板创建一个md5哈希，方法是将图像的所有字节[]组合成一个，然后将其置位

我为这份工作创建了以下疯狂代码：

        public static string GetMD5Hash(byte[] content)
        {
            using (var md5 = MD5.Create())
            {
                byte[] computedHash = md5.ComputeHash(Encoding.UTF8.GetBytes(BitConverter.ToString(content).Replace("-", "")));
                return new System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary(computedHash).ToString();
            }
        }

        private static SQLiteConnection instance;
        public static SQLiteConnection db()
        {
            if (instance == null)
                instance = new SQLiteConnection(System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "TemplatesData.db"));

            return instance;
        }
        public static void CloseConnection()
        {
            if (instance != null)
            {
                instance.Close();
                instance.Dispose();
                instance = null;
            }
        }

    }
    public class TemplateDB
    {
        public static byte[] ConcatByteList(List<byte[]> list)
        {
            return list
                .SelectMany(a => a)
                .ToArray();
        }

        public static Bitmap GetBitmapFromVectorDrawable(Context context, int drawableId)
        {
            Drawable drawable = ContextCompat.GetDrawable(context, drawableId);
            if (Build.VERSION.SdkInt < Android.OS.BuildVersionCodes.Lollipop)
            {
                drawable = (DrawableCompat.Wrap(drawable)).Mutate();
            }

            Bitmap bitmap = Bitmap.CreateBitmap(drawable.IntrinsicWidth,
                    drawable.IntrinsicWidth, Bitmap.Config.Argb8888);
            Canvas canvas = new Canvas(bitmap);
            drawable.SetBounds(0, 0, canvas.Width, canvas.Height);
            drawable.Draw(canvas);

            return bitmap;
        }

        public byte[] DrawableToByteArray(int resourceId)
        {
            var context = AppState.ApplicationState;
            using (var bitmap = GetBitmapFromVectorDrawable(context, resourceId))
            {
                int size = bitmap.ByteCount;
                byte[] byteArray = new byte[size];
                ByteBuffer byteBuffer = ByteBuffer.Allocate(size);
                bitmap.CopyPixelsToBuffer(byteBuffer);
                byteBuffer.Rewind();
                byteBuffer.Get(byteArray);
                return byteArray;
            }
        }
        public static void AddTemplate(int category, List<int> images)
        {
            var templateDB = new TemplateDB();
            var imageByteList = new List<byte[]>();

            foreach (int image in images)
            {
                imageByteList.Add(templateDB.DrawableToByteArray(image));
            }
            var tmpl = new Template()
            {
                Category = category,
            };
            var img1 = new TemplateImage()
            {
                Category = category,
                Image = images[0],
                ImagesHash = DatabaseHelper.GetMD5Hash(imageByteList[0]),
            };
            var img2 = new TemplateImage()
            {
                Category = category,
                Image = images[1],
                ImagesHash = DatabaseHelper.GetMD5Hash(imageByteList[1]),
            };
            var img3 = new TemplateImage()
            {
                Category = category,
                Image = images[2],
                ImagesHash = DatabaseHelper.GetMD5Hash(imageByteList[2]),
            };
            var img4 = new TemplateImage()
            {
                Category = category,
                Image = images[3],
                ImagesHash = DatabaseHelper.GetMD5Hash(imageByteList[3]),
            };
            var img5 = new TemplateImage()
            {
                Category = category,
                Image = images[4],
                ImagesHash = DatabaseHelper.GetMD5Hash(imageByteList[4]),
            };
            tmpl.TemplateImages = new List<TemplateImage>() { img1, img2, img3, img4, img5 };
            tmpl.ImagesHash = DatabaseHelper.GetMD5Hash(ConcatByteList(imageByteList));
            var result = DatabaseHelper.db().Query<TemplateImage>("Select * from Templates where ImagesHash=?", tmpl.ImagesHash);
            if (result.Count == 0)
            {
            DatabaseHelper.db().InsertAll(tmpl.TemplateImages);
            DatabaseHelper.db().Insert(tmpl);
            DatabaseHelper.db().UpdateWithChildren(tmpl);
            }
        }

公共静态字符串GetMD5Hash（字节[]内容）
{
使用（var md5=md5.Create（））
{
byte[]computedHash=md5.ComputeHash（Encoding.UTF8.GetBytes（BitConverter.ToString（content.Replace）（“-”，”））；
返回新的System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary（computedHash.ToString（）；
}
}
私有静态连接实例；
公共静态SQLiteConnection数据库（）
{
if（实例==null）
instance=newsqliteconnection（System.IO.Path.Combine（System.Environment.GetFolderPath（System.Environment.SpecialFolder.Personal），“TemplatesData.db”）；
返回实例；
}
公共静态void CloseConnection（）
{
if（实例！=null）
{
实例Close（）；
Dispose（）；
实例=null；
}
}
}
公共类模板数据库
{
公共静态字节[]ConcatByteList（列表）
{
返回列表
.SelectMany（a=>a）
.ToArray（）；
}
公共静态位图GetBitmapFromVectorDrawable（上下文上下文，int-drawableId）
{
Drawable Drawable=ContextCompat.GetDrawable（上下文，drawableId）；
if（Build.VERSION.SdkIntpublic bool FirstRun { get; set; } = true;
public int DatabaseCreatedVersionOf { get; set; } = -1;

public override void OnCreate()
{
    base.OnCreate();
}

public void UpdateDatabaseCreatedVersion()
{
    DatabaseCreatedVersionOf = Preferences.Get(Settings.DatabaseCreatedVersionOfKey,
       Settings.DatabaseCreatedVersionOfDefault);
}

public void CreateTemplateDB()
{
    UpdateDatabaseCreatedVersion();
    if (DatabaseCreatedVersionOf == -1)
        TemplateDB.CreateDB();
    FirstRun = false;
}
public Template GetTemplateById(int id)
{
    if (FirstRun)
    {
        CreateTemplateDB();
        FirstRun = false;
    }

    return TemplateDB.GetTemplate(id);
}
public List<Template> GetAllTemplates()
{
    if (FirstRun)
    {
        CreateTemplateDB();
        FirstRun = false;
    }

    return TemplateDB.GetAllTemplates();
}