EntityFrameworkCoreの関係

EFコアの関係

リレーショナルデータベースを使用しているときに、必要な要件に従って2つのエンティティを関連付ける必要があります。2つのエンティティ間の関係を確立しようとすると、一方がプリンシパルエンティティとして機能し、もう一方が依存エンティティとして機能します。

最初にこれらの2つの用語を見てから、次に進みましょう。

  • プリンシパルエンティティ:これは、プライマリキープロパティを含むエンティティです。
  • 依存エンティティ:これは、外部キープロパティを含むエンティティです。

エンティティ間の関係は、外部キーを使用して確立されます。これにより、データベースに対してクエリを実行して、意味のある結果を得ることができます。

関係に移る前に、関係を確立するために使用されているいくつかの用語を最初に理解しましょう。

  • 主キー:主キーは、テーブル内の各行を一意に識別するテーブル内の列です。
  • 外部キー:外部キーは、プリンシパルエンティティの主キーをマッピングすることによって2つの列をバインドします。
  • ナビゲーションプロパティ:ナビゲーションプロパティは、エンティティ間の関係のタイプを定義します。要件に基づいて、これらのプロパティは、原則としてエンティティまたは依存エンティティのいずれかで定義されます。

ナビゲーションプロパティには次の2種類があります。

  • 参照ナビゲーションプロパティ:単一の関連エンティティ(ゼロから1または1から1 )への参照を含むプロパティ。
  • コレクションナビゲーションプロパティ:多くの関連エンティティ(1対多または多対多)への参照を保持するプロパティ。

関係の種類

テーブルにはさまざまな関係があります。具体的には、この記事でさらに説明する3つのタイプの関係があります。

  1. 1対1
  2. 1対多
  3. 多対多

1対1の関係

1対1の関係は、1つのテーブルに1つの行があり、別のテーブルの1つの行にのみリンクされている場合、およびその逆の場合に発生します。

理解を深めるために、例を見てみましょう。

クラスStudentStudentAddressについて考えてみます。すべての学生の住所が1つしかないため、StudentとStudentAddressの間に1対1の関係が作成されると仮定します。Student TableのStudentIdは主キーとして機能し、StudentAddressテーブルのStudentAddressIdは、Studentテーブルの主キーを参照する主キーおよび外部キーとして機能します。

モデルは次のようになります。

Student.csモデル

namespace EFCoreRelationships.Models
{
    class Student
    {
        public int StudentID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        //Navigation Property
        public virtual StudentAddress StudentAddress { get; set; }
    }
}

C#

StudentAddressモデル

namespace EFCoreRelationships.Models
{
    class StudentAddress
    {
        [Key,ForeignKey("Student")]
        public int StudentAddressId { get; set; }
        public string StreetAddress { get; set; }
        //Navigation Property
        public virtual Student Student { get; set; }

    }
}

C#

注:ここでは、エンティティフレームワークが遅延読み込みと効率的な変更の追跡を使用できるように、プロパティが仮想として定義されています。

ご覧のとおり、ナビゲーションプロパティが定義されているエンティティを参照する他のエンティティの参照ナビゲーションプロパティを追加しました。この例では、StudentクラスにはStudentAddressナビゲーションプロパティへの参照が含まれ、StudentAddressクラスにはStudentクラスの参照が含まれています。

移行を追加し、データベースを更新して、エンティティ間の1対1の関係を反映するだけです。

1対多の関係

1対多の関係は、最初のテーブルの行が2番目のテーブルの多くの行にリンクされているが、2番目のテーブルの1つの行だけが最初のテーブルの1つの行にリンクされている場合に形成されます。

例を挙げてこれを理解しましょう。

再びStudentStudentCourseを検討します。したがって、各コースには同じ数の学生を含めることができますが、各学生には1つのStudentCourseしかないと仮定します。

したがって、StudentとStudentCourseの関係は1対多です。学生は1つのStudentCourseにのみ属します。StudentCourseには多くの学生を含めることができます。1対多の関係では、StudentCourseテーブルの主キー(StudentCourseID)は、StudentのテーブルでForeignkeyとして定義されます。

1対多の関係の場合、モデルは次のようになります。

Student.csモデル

namespace EFCoreRelationships.Models
{
    class Student
    {
        public int StudentID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        //Navigation Property
        public virtual StudentCourse StudentCourse { get; set; }
    }
}

C#

StudentCourse.csモデル

namespace EFCoreRelationships.Models
{
    class StudentCourse
    {
        public int StudentCourseId { get; set; }
        public string CourseName { get; set; }
        //Collection Navigation Reference
        public virtual ICollection<Student> Students { get; set; }
    }
}

C#

ご覧のとおり、StudentクラスのナビゲーションプロパティはStudentCourseクラスの参照を返します。また、StudentCourseクラスのnavigationプロパティは、Studentのコレクションを返します。EF Coreは、ここで相互に依存するクラスを構成します。

再度移行を追加し、データベースを更新して、SQLServerでの反映を確認します。

多対多の関係

多対多の関係は、あるテーブルの複数の行が別のテーブルの複数の行にリンクされている場合、またはその逆の場合に発生します。

同じ例を続けましょう。

StudentとStudentTeacherは、対多の関係と呼ばれます。生徒には、さまざまな科目を教えるための複数の教師がいます。そして、教師は多くの生徒を持つことができます。このような関係には、多くの場合、結合テーブルの作成が含まれます。StudentテーブルとStudentTeacherテーブルの主キーを組み合わせることにより、結合テーブルの複合主キーが作成されます。

多対多の関係の場合、モデルは次のようになります。

Student.csモデル

namespace EFCoreRelationships.Models
{
    class Student
    {
        public int StudentID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        //Collection Navigation Reference
        public virtual ICollection<StudentTeacher> StudentTeacher { get; set; }
    }
}

C#

StudentTeacher.csモデル

namespace EFCoreRelationships.Models
{
    class StudentTeacher
    {
        public int StudentTeacherId { get; set; }
        public string TeacherName { get; set; }
        //Collection Navigation Reference
        public virtual ICollection<Student> Students { get; set; }
    }
}

C#

ここにあるように、モデルコレクションリファレンスナビゲーションプロパティを使用して、StudentTeacherとStudentのコレクションセットを返し、両方のテーブルの主キーを含み、そのジョイントテーブルの主キーと外部キーとして機能する結合テーブルを作成します。

別の移行および更新データベースを作成して、それを見てみましょう。

StudentStudentTeacherは、StudentTeacherIdStudentStudentIdの両方を主キーおよび外部キーとして含むジョイントテーブルであり、必要に応じてテーブルをクエリできます。

結論

この記事では、EFコアコードファーストアプローチを使用してエンティティ間に1対1、1対多、および多対多の関係を確立する方法を確認し、例を使用してそれを実装しました。

ソース:https ://www.c-sharpcorner.com/article/relationships-in-entity-framework-core/

#entityframework #ef 

EntityFrameworkCoreの関係
John David

John David

1636599722

What's New in Entity Framework Core 6?

EF Core 6 is a cross-platform object-mapper that enables C# developers to use domain classes and strongly typed LINQ queries to interface with a backend database. EF Core 6 is the latest version that features performance improvements, support for temporal tables, cloud-native-friendly migration bundles, improved handling of complex queries and substantial improvements to the Azure Cosmos DB provider. See these new features in action and learn when to use them and why they are helpful in this demo-packed session.

#dotnet #entityframework #ef

What's New in Entity Framework Core 6?

Configure Entity Framework Core in Asp.Net Core MVC 5 with Repository Pattern

https://youtu.be/p8St82l2YNM

#entity framework core #asp.net core mvc 5 #repository pattern #ef #core #mvc

Configure Entity Framework Core in Asp.Net Core MVC 5 with Repository Pattern
Fredy  Larson

Fredy Larson

1599324180

Checking in on NuGet changes, many-to-many in EF Core, community roundup, and more!

Newsletter image

Happy Monday. Do you ever watch a satire and think it’s a documentary?

This week, we’ll:

  • Get excited about many-to-many in EF Core
  • Take a look at some current and upcoming NuGet changes
  • Check in on the community

Many-to-many in EF Core 5Permalink

So this is exciting: many-to-many support is now included in the Entity Framework Core daily builds, and the team spent this week’s community standup showing it off.

A big part of this work includes the concept of skip navigations, or many-to-many navigation properties. For example, here’s a basic model that assigns links in a newsletter (what can I say, it’s fresh on my mind) and is a good use case for many-to-many and is … heavily inspired and/or outright stolen from the GitHub issue:

public class Link
{
    public int LinkId { get; set; }
    public string Url { get; set; }
    public string Description { get; set; }

    public List<LinkTag> LinkTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }
    public string Description { get; set; }

    public List<LinkTag> LinkTags { get; set; }
}

public class LinkTag
{
    public int LinkId { get; set; }
    public Link Link { get; set; }

    public string TagId { get; set; }
    public Tag Tag { get; set; }

    public DateTime LinkCreated { get; set; }
}

So, to load a link and its tags, I’d need to use two navigation properties, and refer to the joining table when performing queries:

var linksAndTags
    = context.Links
        .Include(e => e.LinkTags)
        .ThenInclude(e => e.Tag)
        .ToList();

With many-to-many in EF Core 5, I can skip over the join table and use direct navigation properties. We can instead get a little more direct:

public class Link
{
    public int LinkId { get; set; }
    public string Description { get; set; }

    public List<Tag> Tags { get; set; } // Skips right to Tag
    public List<LinkTag> LinkTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }
    public string Description { get; set; }

    public List<Link> Links { get; set; } // Skips right to Link
    public List<LinkTag> LinkTags { get; set; }
}

#nuget #ef

Checking in on NuGet changes, many-to-many in EF Core, community roundup, and more!
Luna  Mosciski

Luna Mosciski

1596783780

Database Profiling with Visual Studio

Have you ever been tasked with diagnosing a slow performing web application and suspected the database was to blame? Looking into your database tier requires specific tools, now you can quickly and easily investigate using the database profiling tool in Visual Studio’s Performance Explorer!

When it comes to diagnosing the performance of web application, one thing we’ve heard in dozens of conversations with developers, is that the database tier of an application is usually a prime suspect for what is causing sluggishness within an application. However, a quick internet search reveals just how challenging it can be to investigate those issues, most solutions require installing a separate tool, gathering huge SQL traces, or changing your application’s code to get the information you need.

In order to make this process less cumbersome and complicated, we’ve developed the Database tool found within the Performance Profiler in Visual Studio to help you gain deep insight into the database tier of your application. You can see exactly what helpful information about what database activities happen during the execution of your application, such as which queries and transactions are the longest running, which connection string each query is using and perhaps most importantly, where in your code those queries are being made.

Follow the simple example below to see how you can use this tool to pinpoint places in your code that interact with your database and could potentially be improved for meaningful performance gains for your users.

Using the tool

Imagine for example you have an online store such as the excellent ASP.NET Core example eShopOnWeb, this is a great sample application that exercises a lot of the features of .NET Core and uses a SQL database with Entity Framework. After following the directions on the GitHub project page to build and launch the site, take a few moments to click around, filter the catalog and fill your shopping cart with a few items.

Image eshoponweb

Even using the browser’s developer tools there is no way to identify exactly when a database query is happening or if it might be causing a delay during an action like filtering the catalog as seen in the screenshot above. Using the Database tool we can capture the exact database activity that happens during any user action and investigate further.

To do so we’ll simply open the Performance Profiler in Visual Studio by clicking Debug > Performance Profiler or using the keyboard shortcut Alt + F2 and selecting the checkbox next to “Database” to enable the tool. For a more accurate profile, run your application in Release configuration instead of Debug. Then click start to launch and begin profiling your application.

Image launch page

Interact with your application in the ways you’re interested in investigating, then when you’re ready to examine the data, click “Stop Collection” in Visual Studio.

After collection is stopped, Visual Studio will quickly process the data collected and display a table of the queries that happened during your profiling session along with a graph that shows when and how many queries happen over time. Right clicking on any column header reveals the columns available that could help you order, and analyze the activity you recorded. This can make spotting anomalies very quick, such as a long running query that only affects a few records or a query using the wrong connection string.

#cross-platform #data and analytics #visual studio #database #diagnostics #ef #entity framework #performance profiler #profiling #sql

Database Profiling with Visual Studio
Lane  Sanford

Lane Sanford

1592926380

Building a Conversational AI Chatbot With AWS Lambda Function and Amazon EFS

Amazon announced the general availability of AWS Lambda support for Amazon Elastic File System. Amazon EFS is a fully managed, elastic, shared file system and designed to be consumed by other AWS services.
With the release of Amazon EFS for Lambda, we can now easily share data across function invocations. It also opens new capabilities, such as building/importing large libraries and machine learning models directly into Lambda functions. Let’s go over how to build a serverless conversational AI chatbot using Lambda function and EFS.
In this post, we will:

  • Create an Amazon Elastic File System
  • Deploy and run a SageMaker notebook instance and Mount EFS to instance.
  • Download PyTorch libraries and ConvAI pre-trained model to EFS.
  • Add dialog history DynamoDB table and Gateway endpoint to save & retrieve conversation history.
  • Deploy a chatbot engine Lambda function and enable EFS for it.

#ef #aws-lambda #machine-learning #chatbots #serverless

Building a Conversational AI Chatbot With AWS Lambda Function and Amazon EFS
Shayne  Bayer

Shayne Bayer

1592401691

Implementing repository querying interface in EF Core DbContext

How to turn DbContext in EF Core to real unit of work that hosts repository instances by injecting querying classes to DbContext.

#.net #ef #core #ef core dbcontext #programming

Implementing repository querying interface in EF Core DbContext