全16300件 (16300件中 401-450件目)
< 1 ... 4 5 6 7 8 9 10 11 12 13 14 >
以下は、C# WPFでComboBoxに選択アイテムを設定するサンプルコードです。XAML:```xml<Window x:Class="ComboBoxSelectedItemExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:ComboBoxSelectedItemExample" Title="ComboBox SelectedItem Example" Width="300" Height="200"> <Grid> <ComboBox x:Name="myComboBox" HorizontalAlignment="Center" VerticalAlignment="Center" Width="150"> <ComboBoxItem Content="Item 1"/> <ComboBoxItem Content="Item 2"/> <ComboBoxItem Content="Item 3"/> </ComboBox> <Button Content="Set Selected Item" HorizontalAlignment="Center" VerticalAlignment="Bottom" Click="Button_Click"/> </Grid></Window>```C#:```csharpusing System.Windows;namespace ComboBoxSelectedItemExample{ public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void Button_Click(object sender, RoutedEventArgs e) { // コンボボックスの選択アイテムを設定する myComboBox.SelectedItem = myComboBox.Items[1]; // 例えば、2番目のアイテムを選択する } }}```この例では、ComboBoxに3つのアイテムがあります。ButtonのClickイベントハンドラで、ComboBoxのSelectedItemプロパティを設定して、選択アイテムを変更しています。この場合、2番目のアイテムが選択されます。
2024.03.14
`CommandParameter`に5つの引数を設定する場合、これらの引数を単一のオブジェクトにまとめて渡すことができます。一般的には、匿名型やカスタムのクラスオブジェクトを使用して引数をまとめます。以下は、匿名型を使用して5つの引数を`CommandParameter`に渡すサンプルコードです。XAML:```xml<Button Content="Click" Command="{Binding MyCommand}" CommandParameter="{Binding MyParameters}"/>```ViewModel:```csharpusing System.Windows.Input;using Prism.Commands;public class MainViewModel{ public ICommand MyCommand { get; } public object MyParameters { get; } // 複数の引数を含むオブジェクト public MainViewModel() { // ボタンがクリックされたときに実行されるコマンド MyCommand = new DelegateCommand(ExecuteMyCommand); // 5つの引数を含む匿名型を作成し、MyParametersに設定 MyParameters = new { Arg1 = "Value1", Arg2 = 123, Arg3 = true, Arg4 = 3.14, Arg5 = SomeEnum.Value // 任意の値 }; } private void ExecuteMyCommand() { // コマンドが実行されたときに引数を処理する // MyParametersをキャストして必要な値にアクセスする dynamic parameters = MyParameters; string arg1 = parameters.Arg1; int arg2 = parameters.Arg2; bool arg3 = parameters.Arg3; double arg4 = parameters.Arg4; SomeEnum arg5 = parameters.Arg5; // ここで引数を使用した処理を行う } // 必要に応じて、引数の型に対応するプロパティを定義する public enum SomeEnum { Value, OtherValue }}```この例では、`MyParameters`プロパティに5つの引数を含む匿名型を作成し、`CommandParameter`にバインドしています。`DelegateCommand`を使用してコマンドを作成し、そのコマンドが実行されたときに`ExecuteMyCommand`メソッドが呼び出されます。`ExecuteMyCommand`メソッドでは、`MyParameters`プロパティをキャストして、必要な値にアクセスして処理を行います。
2024.03.14
C# WPFで`Command`を呼び出す際に5つの引数を渡す方法はいくつかありますが、一般的な方法は、次のような方法です。1. コマンドパラメーターを使用する:`CommandParameter`プロパティを使用して、任意のデータをコマンドに渡すことができます。この場合、コマンド自体がコマンドパラメーターを処理する必要があります。2. バインディングを使用する:バインディングを介して、複数のプロパティをコマンドに渡すことができます。この場合、`MultiBinding`や`MultiValueConverter`を使用して複数の値をまとめることができます。以下は、`CommandParameter`を使用してコマンドに5つの引数を渡す方法の例です。XAML:```xml<Button Content="Click" Command="{Binding MyCommand}" CommandParameter="{Binding MyParameters}"/>```ViewModel:```csharpusing System.Collections.Generic;using System.Windows.Input;using Prism.Commands;public class MainViewModel{ public ICommand MyCommand { get; } public List<object> MyParameters { get; } = new List<object>(); public MainViewModel() { MyCommand = new DelegateCommand<object>(ExecuteMyCommand); } private void ExecuteMyCommand(object parameter) { // MyParametersに渡された引数が格納されています }}```この例では、`MyCommand`プロパティにバインドされたボタンがあり、`MyParameters`プロパティがコマンドパラメーターとして渡されています。`DelegateCommand<object>`を使用してコマンドを作成し、`ExecuteMyCommand`メソッドがコマンドの実行を処理します。`MyParameters`プロパティには、ボタンがクリックされたときに渡される引数が格納されます。これにより、必要な数の引数を渡すことができます。
2024.03.14
C# WPFで`ICommand`の基底クラスを作成する際には、通常は`ICommand`インターフェースを実装し、`Execute`および`CanExecute`メソッドをオーバーライドするクラスを作成します。また、`CanExecuteChanged`イベントを適切に処理する必要があります。以下は、`ICommand`の基底クラスを作成する例です。```csharpusing System;using System.Windows.Input;public abstract class BaseCommand : ICommand{ public event EventHandler CanExecuteChanged; public bool CanExecute(object parameter) { return OnCanExecute(parameter); } public void Execute(object parameter) { OnExecute(parameter); } protected virtual bool OnCanExecute(object parameter) { return true; // デフォルトでは常に実行可能とします。必要に応じて派生クラスでオーバーライドします。 } protected abstract void OnExecute(object parameter); protected void RaiseCanExecuteChanged() { CanExecuteChanged?.Invoke(this, EventArgs.Empty); }}```この`BaseCommand`クラスは`ICommand`インターフェースを実装し、`CanExecuteChanged`イベントを処理するための標準的な実装を提供します。派生クラスは、`OnCanExecute`および`OnExecute`メソッドを実装する必要があります。以下は、`BaseCommand`を継承してカスタムのコマンドを作成する例です。```csharppublic class MyCommand : BaseCommand{ protected override bool OnCanExecute(object parameter) { // 実行可能な条件をここで判定します。 return true; } protected override void OnExecute(object parameter) { // コマンドの実行内容をここで記述します。 }}```このようにして、`BaseCommand`を使用することで、簡潔かつ再利用可能な`ICommand`の実装を行うことができます。
2024.03.14
WPFでは、Ellipse(楕円)を使用して独自のプログレスバーを作成することができます。以下は、Ellipseを利用してプログレスバーを実装するサンプルコードです。```xml<Window x:Class="ProgressBarEllipseExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Progress Bar Ellipse Example" Width="300" Height="300"> <Grid> <!-- 背景の楕円 --> <Ellipse Width="200" Height="200" Stroke="LightGray" StrokeThickness="10" HorizontalAlignment="Center" VerticalAlignment="Center"/> <!-- プログレスバー用の楕円 --> <Ellipse x:Name="progressEllipse" Width="200" Height="200" Stroke="DodgerBlue" StrokeThickness="10" HorizontalAlignment="Center" VerticalAlignment="Center"/> </Grid></Window>```このサンプルコードでは、2つのEllipseを使用してプログレスバーを作成しています。1つは背景の楕円であり、もう1つはプログレスバー用の楕円です。プログレスバー用の楕円のStrokeプロパティを変更することで、進捗状況を表示します。C#コードビハインドで、プログレスバーを操作することもできます。例えば、プログレスバーのStrokeプロパティを変更して進捗状況を変更することができます。以下はその例です。```csharpusing System;using System.Windows;using System.Windows.Threading;namespace ProgressBarEllipseExample{ public partial class MainWindow : Window { private DispatcherTimer timer; private double progress; public MainWindow() { InitializeComponent(); Loaded += MainWindow_Loaded; } private void MainWindow_Loaded(object sender, RoutedEventArgs e) { // タイマーを初期化してプログレスバーを更新 timer = new DispatcherTimer(); timer.Interval = TimeSpan.FromMilliseconds(100); timer.Tick += Timer_Tick; timer.Start(); } private void Timer_Tick(object sender, EventArgs e) { // プログレスバーの進捗を更新 progress += 0.01; if (progress > 1) progress = 0; // プログレスバー用の楕円のStrokeプロパティを更新して進捗状況を反映 progressEllipse.StrokeDashArray = new DoubleCollection() { progress * progressEllipse.Width, 10000 }; } }}```このコードでは、DispatcherTimerを使用して定期的にプログレスバーの進捗を更新しています。プログレスバー用の楕円のStrokeDashArrayプロパティを使用して進捗状況を反映しています。
2024.03.14
WPFでは、Ellipse(楕円)を使用して星形のボタンを作成することが可能です。一般的な方法は、楕円の形状を使用して星形を描画することです。以下は、C# WPFで星形のボタンを作成するサンプルコードです。```xml<Window x:Class="StarButtonExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Star Button Example" Width="300" Height="300"> <Grid> <Button Width="100" Height="100" HorizontalAlignment="Center" VerticalAlignment="Center"> <Button.Template> <ControlTemplate TargetType="Button"> <Grid> <!-- 内側の楕円 --> <Ellipse Width="80" Height="80" Fill="Yellow"/> <!-- 星形 --> <Path Width="50" Height="50" Data="M25,0 L32,20 L50,20 L36,32 L42,50 L25,38 L8,50 L14,32 L0,20 L18,20 Z" Stretch="Fill" Fill="Red" Margin="15"/> </Grid> </ControlTemplate> </Button.Template> </Button> </Grid></Window>```このサンプルコードでは、Buttonコントロールのテンプレートをカスタマイズして星形のボタンを作成しています。内側に黄色の楕円を描画し、その上にPathコントロールを使用して星形を描画しています。PathのDataプロパティには星形の描画パスが定義されています。このXAMLコードを実行すると、星形のボタンが表示されるウィンドウが表示されます。
2024.03.14
WPFのEllipse(楕円)は、UIデザインにおいてさまざまな場面で活用されます。以下は、Ellipseを利用したほうが良い場面のいくつかです。1. **アイコンやボタンのデザイン**: 楕円形のアイコンやボタンは、ユーザーの注目を集めやすく、視覚的に興味深いデザインにすることができます。特に円形のボタンは、特定のアクションを実行するための洗練された外観を提供します。2. **プログレスバー**: 楕円形のプログレスバーは、特に円形のプログレスを示すのに適しています。例えば、ダウンロードやアップロードの進捗状況を表示するために使用できます。これは、ユーザーに進行状況を直感的に伝えるのに役立ちます。3. **UI上の要素の装飾**: 楕円形の図形は、UI上の要素を装飾するためにも使用できます。例えば、情報を強調したり、アイデアを分かりやすく伝えるために使用できます。楕円形のラベルやマーカーは、視覚的な分離を作成するのに役立ちます。4. **トグルボタン**: 楕円形の形状は、トグルボタンやスイッチのデザインにも適しています。円形のトグルボタンは、オンとオフの状態を示すための直感的な方法を提供し、ユーザーに操作を理解しやすくします。5. **データの視覚化**: 楕円形のグラフは、円グラフなどのデータの視覚化に役立ちます。特定のカテゴリや項目の割合を表現するのに有用であり、ビジュアルにデータのパターンや関係を理解するのに役立ちます。これらは、Ellipseを利用したほうが良い場面の一部です。一般的には、視覚的な強調やデザインの改善を目指す場合にEllipseが役立ちます。
2024.03.14
以下は、C# WPFでEllipse(楕円)を利用するサンプルコードです。```xml<Window x:Class="EllipseExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Ellipse Example" Width="300" Height="300"> <Grid> <Ellipse Width="100" Height="100" Fill="Blue" HorizontalAlignment="Center" VerticalAlignment="Center"/> </Grid></Window>```この例では、`Ellipse`コントロールを使用して青色の楕円を作成しています。`Width`と`Height`プロパティを設定して楕円のサイズを指定し、`Fill`プロパティを使用して楕円の塗りつぶし色を指定しています。楕円は`Grid`内に配置されており、`HorizontalAlignment`と`VerticalAlignment`プロパティを使用して中央に配置されています。このXAMLコードを実行すると、楕円が表示されるウィンドウが表示されます。
2024.03.14
以下は、C#WPFで`Page`に`DataContext`を設定するサンプルコードです。まず、`DataContext`となるクラスを定義します。```csharpusing System.ComponentModel;public class MyData : INotifyPropertyChanged{ private string message; public string Message { get { return message; } set { if (message != value) { message = value; OnPropertyChanged(nameof(Message)); } } } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); }}```次に、`Page`を作成し、その`DataContext`を`MyData`クラスのインスタンスに設定します。```xml<!-- MyPage.xaml --><Page x:Class="WpfApp.MyPage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> <Grid> <TextBlock Text="{Binding Message}" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="24"/> </Grid></Page>``````csharp// MyPage.xaml.csusing System.Windows.Controls;namespace WpfApp{ public partial class MyPage : Page { public MyPage() { InitializeComponent(); // DataContextにMyDataクラスのインスタンスを設定 DataContext = new MyData { Message = "Hello, WPF!" }; } }}```これで、`MyPage`の`TextBlock`が`MyData`クラスの`Message`プロパティにバインドされ、"Hello, WPF!"と表示されます。また、XAMLファイルで直接`DataContext`を指定することもできます。```xml<!-- MyPage.xaml --><Page x:Class="WpfApp.MyPage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:WpfApp" DataContext="{x:Static local:MyStaticData}"> <Grid> <TextBlock Text="{Binding Message}" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="24"/> </Grid></Page>````MyStaticData`は、`MyData`のインスタンスを静的プロパティとして提供するクラスです。
2024.03.14
`Frame`コントロールは、WPFアプリケーション内でページのナビゲーションを実現するために使用されます。以下は、`Frame`コントロールを使用してページのナビゲーションを行うサンプルコードです。まず、2つのページを作成します。1つはホームページであり、もう1つはサブページです。```xml<!-- HomePage.xaml --><Page x:Class="WpfApp.HomePage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> <Grid> <TextBlock Text="ホームページ" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="24"/> <Button Content="サブページへ" Click="Button_Click" HorizontalAlignment="Center" VerticalAlignment="Bottom" Margin="0,0,0,20"/> </Grid></Page>``````xml<!-- SubPage.xaml --><Page x:Class="WpfApp.SubPage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> <Grid> <TextBlock Text="サブページ" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="24"/> </Grid></Page>```次に、`Frame`コントロールを含むメインウィンドウを作成します。```xml<!-- MainWindow.xaml --><Window x:Class="WpfApp.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:WpfApp" Title="MainWindow" Height="450" Width="800"> <Grid> <Grid.ColumnDefinitions> <ColumnDefinition Width="Auto"/> <ColumnDefinition Width="*"/> </Grid.ColumnDefinitions> <StackPanel Grid.Column="0"> <Button Content="ホームページ" Click="HomeButton_Click"/> <Button Content="サブページ" Click="SubButton_Click"/> </StackPanel> <Frame x:Name="mainFrame" Grid.Column="1"/> </Grid></Window>```最後に、コードビハインドでボタンクリックイベントを処理して、`Frame`コントロールのページを変更します。```csharp// MainWindow.xaml.csusing System.Windows;namespace WpfApp{ public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void HomeButton_Click(object sender, RoutedEventArgs e) { // ホームページに移動 mainFrame.Navigate(new HomePage()); } private void SubButton_Click(object sender, RoutedEventArgs e) { // サブページに移動 mainFrame.Navigate(new SubPage()); } }}```これで、ボタンをクリックすると、`Frame`コントロール内でページが切り替わります。
2024.03.14
以下は、C#WPFでWin32APIを使用してウィンドウのタイトルを取得するサンプルコードです。まず、`WindowInteropHelper`クラスを使用してウィンドウのハンドルを取得し、`GetWindowText`関数を呼び出してウィンドウのタイトルを取得します。```csharpusing System;using System.Runtime.InteropServices;using System.Windows;using System.Windows.Interop;namespace Win32APISample{ public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); Loaded += MainWindow_Loaded; } private void MainWindow_Loaded(object sender, RoutedEventArgs e) { string windowTitle = GetWindowTitle(); MessageBox.Show($"ウィンドウのタイトル: {windowTitle}"); } private string GetWindowTitle() { IntPtr hWnd = new WindowInteropHelper(this).Handle; const int nChars = 256; var sb = new System.Text.StringBuilder(nChars); if (GetWindowText(hWnd, sb, nChars) > 0) { return sb.ToString(); } return null; } [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] private static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder lpString, int nMaxCount); }}```このコードでは、`GetWindowTitle`メソッドを使用してウィンドウのタイトルを取得し、それをメッセージボックスで表示しています。`GetWindowText`関数は、ウィンドウのハンドルを受け取り、ウィンドウのタイトルを取得します。このサンプルを実行すると、WPFウィンドウのタイトルがメッセージボックスに表示されます。
2024.03.14
以下は、ASP.NET Core MVCアプリケーションでOracleデータベースに接続し、データを表示するサンプルコードです。Oracleデータベースへの接続にはOracle.ManagedDataAccess.Coreパッケージを使用します。まず、NuGetパッケージマネージャーコンソールでOracle.ManagedDataAccess.Coreパッケージをインストールします。```bashInstall-Package Oracle.ManagedDataAccess.Core```次に、以下のサンプルコードを使用してOracleに接続し、データを取得して表示します。```csharp// Models/Employee.csusing System;namespace YourNamespace.Models{ public class Employee { public int Id { get; set; } public string Name { get; set; } public string Department { get; set; } public decimal Salary { get; set; } // Add more properties as needed }}``````csharp// Services/EmployeeService.csusing System;using System.Collections.Generic;using Oracle.ManagedDataAccess.Client;using YourNamespace.Models;namespace YourNamespace.Services{ public class EmployeeService { private readonly string _connectionString; public EmployeeService(string connectionString) { _connectionString = connectionString; } public List<Employee> GetEmployees() { var employees = new List<Employee>(); using (var connection = new OracleConnection(_connectionString)) { connection.Open(); var command = new OracleCommand("SELECT * FROM Employees", connection); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var employee = new Employee { Id = Convert.ToInt32(reader["Id"]), Name = reader["Name"].ToString(), Department = reader["Department"].ToString(), Salary = Convert.ToDecimal(reader["Salary"]) }; employees.Add(employee); } } } return employees; } }}``````csharp// Controllers/HomeController.csusing Microsoft.AspNetCore.Mvc;using YourNamespace.Services;namespace YourNamespace.Controllers{ public class HomeController : Controller { private readonly EmployeeService _employeeService; public HomeController(EmployeeService employeeService) { _employeeService = employeeService; } public IActionResult Index() { var employees = _employeeService.GetEmployees(); return View(employees); } }}``````html<!-- Views/Home/Index.cshtml -->@model List<YourNamespace.Models.Employee>@{ ViewData["Title"] = "Employee List";}<h1>Employee List</h1><table class="table"> <thead> <tr> <th>ID</th> <th>Name</th> <th>Department</th> <th>Salary</th> </tr> </thead> <tbody> @foreach (var employee in Model) { <tr> <td>@employee.Id</td> <td>@employee.Name</td> <td>@employee.Department</td> <td>@employee.Salary</td> </tr> } </tbody></table>```これは、OracleデータベースのEmployeesテーブルから従業員のデータを取得し、ASP.NET Core MVCアプリケーションのビューで表示するサンプルです。必要に応じて接続文字列とテーブルのカラムを適切に調整してください。
2024.03.14
以下は、ASP.NETでC#を使用したサンプルコードの例です。この例では、ASP.NET Core MVCを使用しています。```csharp// HomeController.csusing Microsoft.AspNetCore.Mvc;namespace YourNamespace.Controllers{ public class HomeController : Controller { public IActionResult Index() { return View(); } }}``````csharp// Startup.csusing Microsoft.AspNetCore.Builder;using Microsoft.AspNetCore.Hosting;using Microsoft.Extensions.Configuration;using Microsoft.Extensions.DependencyInjection;using Microsoft.Extensions.Hosting;namespace YourNamespace{ public class Startup { public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get; } public void ConfigureServices(IServiceCollection services) { services.AddControllersWithViews(); } public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseRouting(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); }); } }}``````html<!-- Views/Home/Index.cshtml -->@{ ViewData["Title"] = "Home Page";}<div class="text-center"> <h1 class="display-4">Welcome</h1> <p>Learn about ASP.NET Core MVC.</p></div>```これは、単純なASP.NET Core MVCアプリケーションの例です。HomeControllerがアプリケーションのコントローラーであり、IndexアクションはViews/Home/Index.cshtmlというビューを返します。Startup.csファイルでは、アプリケーションの構成とルーティングが設定されます。
2024.03.14
`CollectionViewSource`は、WPFでデータをフィルタリング、並べ替え、グループ化するための機能を提供します。以下は、`CollectionViewSource`を使用してデータをフィルタリングするサンプルコードです。まず、XAMLファイルで`CollectionViewSource`を定義します。```xml<Window x:Class="CollectionViewSourceExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="450" Width="800"> <Window.Resources> <CollectionViewSource x:Key="MyDataView" Source="{Binding MyData}" Filter="MyDataView_Filter"/> </Window.Resources> <Grid> <ListBox ItemsSource="{Binding Source={StaticResource MyDataView}}"/> </Grid></Window>```この例では、`CollectionViewSource`を`MyDataView`として定義し、`MyData`プロパティからデータを取得します。また、`Filter`イベントハンドラを指定して、データのフィルタリングを行います。次に、ビューモデルでデータを定義し、`CollectionViewSource`にバインドします。```csharpusing System;using System.Collections.ObjectModel;using System.ComponentModel;using System.Windows.Data;namespace CollectionViewSourceExample{ public class MainViewModel { public ObservableCollection<string> MyData { get; set; } public ICollectionView MyDataView { get; set; } public MainViewModel() { MyData = new ObservableCollection<string> { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" }; MyDataView = CollectionViewSource.GetDefaultView(MyData); MyDataView.Filter = MyDataView_Filter; } private bool MyDataView_Filter(object item) { // "Item"で始まる文字列のみ表示 return (item as string)?.StartsWith("Item") == true; } }}```この例では、`MainViewModel`で`MyData`プロパティにデータを設定し、そのデータを`CollectionViewSource`のソースとして使用します。また、`MyDataView_Filter`メソッドでデータのフィルタリングロジックを定義します。これで、`CollectionViewSource`を使用してデータをフィルタリングするサンプルコードが完成しました。
2024.03.14
`ObservableCollection`は、WPFで頻繁に使用されるクラスであり、`INotifyCollectionChanged`インターフェースを実装しています。これにより、コレクションに変更が加えられたときに自動的に通知を受け取ることができます。つまり、コレクション内の要素が追加、削除、クリアされたときに、これらの変更がUIに反映されます。以下は、`ObservableCollection`の基本的な使用方法のサンプルコードです。```csharpusing System.Collections.ObjectModel;public class MainViewModel{ public ObservableCollection<string> Items { get; set; } public MainViewModel() { // ObservableCollectionのインスタンスを作成 Items = new ObservableCollection<string>(); // データを追加 Items.Add("Item 1"); Items.Add("Item 2"); // データを削除 Items.Remove("Item 1"); }}```この例では、`ObservableCollection`を使用して文字列のコレクションを作成し、データを追加してから削除しています。これにより、`ObservableCollection`が自動的にUIに通知を送信し、変更が反映されます。XAMLで`ObservableCollection`をバインドする場合、データが変更されるとUIが自動的に更新されます。```xml<ListBox ItemsSource="{Binding Items}"/>```このXAMLコードは、`MainViewModel`の`Items`プロパティにバインドされた`ListBox`を表示します。`Items`プロパティは`ObservableCollection<string>`であり、要素が追加または削除されると`ListBox`の内容が自動的に更新されます。`ObservableCollection`はUIとデータのバインディングにおいて非常に便利です。データが変更されたときにUIが自動的に更新されるため、コレクションに関連付けられたデータを動的に表示する必要がある場合に役立ちます。
2024.03.14
以下は、C#WPFで`IValueConverter`を使用するサンプルコードです。この例では、`IValueConverter`を実装して、データバインディング中に値の変換を行います。まず、`IValueConverter`を実装したカスタムのコンバータを作成します。```csharpusing System;using System.Globalization;using System.Windows.Data;public class AgeToStringConverter : IValueConverter{ public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value is int age) { // 例として、18歳未満なら"未成年"、18歳以上なら"成人"を返す return age < 18 ? "未成年" : "成人"; } return "不明"; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { throw new NotImplementedException(); }}```次に、このコンバータを使用して値を変換するXAMLファイルを作成します。```xml<Window x:Class="ValueConverterExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:ValueConverterExample" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800"> <Window.Resources> <local:AgeToStringConverter x:Key="AgeConverter"/> </Window.Resources> <Grid> <StackPanel> <TextBox x:Name="ageTextBox" Text="{Binding Age, UpdateSourceTrigger=PropertyChanged}"/> <TextBlock Text="{Binding Age, Converter={StaticResource AgeConverter}}"/> </StackPanel> </Grid></Window>```最後に、ビューモデルを作成してXAMLファイルにバインドします。```csharpusing System.ComponentModel;public class MainViewModel : INotifyPropertyChanged{ private int age; public int Age { get { return age; } set { if (age != value) { age = value; OnPropertyChanged(nameof(Age)); } } } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); }}```このコードでは、`AgeToStringConverter`を使用して`TextBox`に入力された年齢を"未成年"または"成人"に変換して、`TextBlock`に表示しています。
2024.03.14
以下は、C#WPFで`ICommand`を使用するサンプルコードです。このサンプルでは、`ICommand`を実装してボタンのクリックイベントを処理し、MVVMパターンを使用してボタンのクリックをハンドリングします。まず、`RelayCommand`と呼ばれるカスタムの`ICommand`実装を作成します。```csharpusing System;using System.Windows.Input;public class RelayCommand : ICommand{ private readonly Action<object> execute; private readonly Func<object, bool> canExecute; public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null) { this.execute = execute ?? throw new ArgumentNullException(nameof(execute)); this.canExecute = canExecute; } public event EventHandler CanExecuteChanged { add { CommandManager.RequerySuggested += value; } remove { CommandManager.RequerySuggested -= value; } } public bool CanExecute(object parameter) { return canExecute == null || canExecute(parameter); } public void Execute(object parameter) { execute(parameter); }}```次に、この`RelayCommand`を使用してビューモデルを作成します。```csharpusing System;using System.Windows.Input;public class MainViewModel{ public ICommand ClickCommand { get; } public MainViewModel() { ClickCommand = new RelayCommand(OnClick); } private void OnClick(object parameter) { Console.WriteLine("ボタンがクリックされました!"); }}```最後に、XAMLファイルでビューを作成します。```xml<Window x:Class="CommandExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:CommandExample" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800"> <Window.DataContext> <local:MainViewModel/> </Window.DataContext> <Grid> <Button Content="クリック" Command="{Binding ClickCommand}"/> </Grid></Window>```このコードでは、ボタンがクリックされたときに`MainViewModel`の`ClickCommand`が実行されます。`RelayCommand`を使用することで、XAMLファイルで`Command`プロパティに直接バインドすることができます。
2024.03.14
`DataRow`内のデータ変更を破棄するには、`DataRow`の`RejectChanges()`メソッドを使用します。このメソッドを呼び出すと、`DataRow`に対して行われたすべての変更が取り消され、元の状態に戻ります。以下は、`RejectChanges()`メソッドを使用して`DataRow`内のデータ変更を破棄する例です。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; table.Rows.Add(row); // データを変更します。 row.BeginEdit(); row["Name"] = "James"; row.EndEdit(); // データが変更されたことを確認します。 Console.WriteLine($"Nameの変更前の値: {row["Name", DataRowVersion.Original]}"); // 変更前の値: John Console.WriteLine($"Nameの変更後の値: {row["Name", DataRowVersion.Current]}"); // 変更後の値: James // データ変更を破棄します。 row.RejectChanges(); // データ変更が破棄されたことを確認します。 Console.WriteLine($"Nameの変更後の値(破棄後): {row["Name"]}"); // 変更後の値(破棄後): John Console.ReadLine(); }}```この例では、最初にデータを変更し、その後`RejectChanges()`メソッドを使用して変更を破棄しています。`RejectChanges()`メソッドを呼び出した後は、データ行が元の状態に戻ります。
2024.03.14
`DataRow`の`RowState`が`Deleted`になる場合と`Detached`になる場合の違いについて説明します。1. `Deleted`: - `Deleted`状態は、データ行が`DataTable`にまだ属しているが、削除操作が適用されたことを示します。つまり、`DataTable.Rows.Remove()`メソッドなどによってデータ行が削除され、`DataTable`の`Rows`コレクションからは削除されましたが、まだ`DataTable`の一部として存在しています。データ行は、実際には`DataRowCollection`の一部としてマークされ、それを通じてアクセス可能です。ただし、データベースに反映されることはありません。 - この状態の`DataRow`は、削除操作が発生した列の元の値にアクセスすることができます。削除されたデータ行のデータは一時的に保持され、必要に応じて元に戻すことができます。2. `Detached`: - `Detached`状態は、データ行が`DataTable`から切り離されたことを示します。つまり、`DataTable.Rows.Remove()`メソッドなどによってデータ行が`DataTable`から削除され、`DataTable`の`Rows`コレクションからも削除されました。データ行は、もはや`DataTable`の一部ではなく、その状態を保持します。 - この状態の`DataRow`は、`DataTable`から切り離されているため、データ行の元の値や変更された値にアクセスすることはできません。データ行の変更は、`DataTable`に影響を与えません。つまり、`Deleted`状態はデータ行が`DataTable`にまだ属しており、削除操作が適用された状態を示し、`Detached`状態はデータ行が`DataTable`から切り離された状態を示します。
2024.03.14
`DataRow`の`RowState`が`Detached`になるのは、データ行が`DataTable`から切り離された場合です。つまり、そのデータ行が`DataTable`の`Rows`コレクションに含まれておらず、また`DataRow`オブジェクト自体が`DataTable`の一部ではない場合です。主な場面としては次のようなケースが考えられます:1. 新しい`DataRow`オブジェクトが作成され、`DataTable.Rows.Add()`メソッドを使用せずに直接データ行にデータが設定された場合。2. あるいは、`DataRow`オブジェクトが`DataTable`から取得されたが、その後`DataTable.Rows.Remove()`メソッドまたは`DataTable.Clear()`メソッドによって`DataTable`から削除された場合。つまり、`Detached`の状態は、`DataRow`オブジェクトが`DataTable`から切り離され、データ行のコレクションから削除されたことを示します。この状態では、データ行に対する変更は`DataTable`に影響を与えません。以下に、`DataRow`の`RowState`が`Detached`になる例を示します。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; // DataTableからDataRowを削除し、Detached状態にします。 table.Rows.Remove(row); // DataRowの状態を確認します。 Console.WriteLine($"DataRowの状態: {row.RowState}"); // DataRowの状態: Detached Console.ReadLine(); }}```この例では、`DataRow`オブジェクトを`DataTable`から削除し、その後`RowState`が`Detached`になることを確認しています。
2024.03.14
`DataRow`の`RowState`プロパティの値は、`DataRowState`列挙型によって定義されています。以下に、`DataRowState`列挙型の値とそれぞれの意味を示します。1. `Unchanged`: データ行は変更されていません。2. `Added`: データ行がテーブルに追加されましたが、まだコミットされていません。3. `Deleted`: データ行が削除され、`DataRow`がテーブルから削除されましたが、まだコミットされていません。4. `Modified`: データ行が変更されましたが、まだコミットされていません。5. `Detached`: データ行はテーブルに属していません。これらの値は、`DataRow`の状態を示します。例えば、`Unchanged`はデータ行が変更されていないことを示し、`Added`はデータ行が新しく追加されたことを示します。以下は、C#での使用例です。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { // サンプルのDataTableを作成し、1行のデータを追加します。 DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; table.Rows.Add(row); // DataRowの状態を確認します。 Console.WriteLine($"DataRowの状態: {row.RowState}"); // DataRowの状態: Unchanged // データを変更します。 row["Name"] = "James"; // DataRowの状態を再度確認します。 Console.WriteLine($"DataRowの状態: {row.RowState}"); // DataRowの状態: Modified Console.ReadLine(); }}```このコードでは、最初にデータを追加した直後の`RowState`が`Unchanged`であることを確認し、その後、データを変更して`RowState`が`Modified`に変わることを確認しています。
2024.03.14
`DataRow`が変更されたかどうかを判定するには、`DataRow`の`RowState`プロパティを確認します。`RowState`プロパティは、`DataRow`の現在の状態を示す列挙型`DataRowState`の値を取得します。以下は、`DataRow`が変更されたかどうかを判定する方法のサンプルコードです。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { // サンプルのDataTableを作成し、1行のデータを追加します。 DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; table.Rows.Add(row); // データが変更されていないことを確認します。 Console.WriteLine($"DataRowの状態: {row.RowState}"); // DataRowの状態: Unchanged // データを変更します。 row["Name"] = "James"; // データが変更されたことを確認します。 Console.WriteLine($"DataRowの状態: {row.RowState}"); // DataRowの状態: Modified Console.ReadLine(); }}```このサンプルでは、最初に`DataRow`を作成し、データが追加された直後の`RowState`を表示しています。その後、`Name`列の値を変更し、`RowState`が`Modified`に変更されたことを確認しています。したがって、`DataRow`の`RowState`プロパティを使用して、`DataRow`が変更されたかどうかを簡単に判定することができます。
2024.03.14
`DataRowVersion.Original`は、`DataRow`オブジェクトの状態が`DataRowState.Modified`(変更された)の場合に、変更前の値にアクセスするために使用されます。つまり、変更が行われる前のDataRowの値を取得する際に使用されます。例えば、データベースからデータをロードし、変更を加えた後に元の値と変更後の値を比較したい場合、`DataRowVersion.Original`を使用して元の値にアクセスできます。以下は、`DataRowVersion.Original`の使用例です。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { // サンプルのDataTableを作成し、1行のデータを追加します。 DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; table.Rows.Add(row); // データを変更します。 row.BeginEdit(); row["Name"] = "James"; row.EndEdit(); // データをロードした後の元の値と変更後の値を比較します。 CompareValues(row, "Name"); // 変更前の値: John, 変更後の値: James Console.ReadLine(); } private static void CompareValues(DataRow row, string columnName) { object originalValue = row[columnName, DataRowVersion.Original]; object currentValue = row[columnName, DataRowVersion.Current]; Console.WriteLine($"変更前の値: {originalValue}, 変更後の値: {currentValue}"); }}```この例では、最初にデータをロードし、後で`Name`列の値を`John`から`James`に変更しています。その後、`CompareValues`メソッドを使用して、変更前の値と変更後の値を比較しています。`DataRowVersion.Original`を使用することで、変更前の値にアクセスし、その後の変更後の値と比較することができます。
2024.03.14
以下は、C#でDataRowに格納されている値を取得するサンプルコードです。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { // サンプルのDataTableを作成し、1行のデータを追加します。 DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); table.Columns.Add("Age", typeof(int)); DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; row["Age"] = 30; table.Rows.Add(row); // DataRowから値を取得します。 int id = (int)row["ID"]; string name = (string)row["Name"]; int age = (int)row["Age"]; // 取得した値を表示します。 Console.WriteLine($"ID: {id}, Name: {name}, Age: {age}"); Console.ReadLine(); }}```このサンプルでは、DataTableに1行のデータを追加し、その行の各列の値を取得して表示しています。DataRowの各列は、列の名前または列のインデックスを使用してアクセスできます。データ型が異なる場合は、適切なキャストを使用して値を取得します。
2024.03.14
DataRowのOldValueを取得するには、通常、DataRowの`AcceptChanges`メソッドが呼び出される前にその変更が行われたかどうかを確認する必要があります。DataRowの`AcceptChanges`メソッドが呼び出されると、DataRowの状態が更新され、新しい値が現在の値として設定され、古い値は削除されます。以下は、DataRowからOldValueを取得するサンプルコードです。```csharpusing System;using System.Data;class Program{ static void Main(string[] args) { // 例として、DataTableを作成し、1つの行を追加します。 DataTable table = new DataTable("SampleTable"); table.Columns.Add("ID", typeof(int)); table.Columns.Add("Name", typeof(string)); // DataRowの変更を監視するイベントハンドラを設定します。 table.RowChanged += Table_RowChanged; DataRow row = table.NewRow(); row["ID"] = 1; row["Name"] = "John"; table.Rows.Add(row); // 変更を行います。 row.BeginEdit(); row["Name"] = "James"; row.EndEdit(); // OldValueを取得します。 PrintOldValue(row, "Name"); // これは "John" を表示するはずです。 // DataRowの状態を変更し、AcceptChangesメソッドを呼び出します。 row.AcceptChanges(); // OldValueを取得しようとすると、nullが返されます。 PrintOldValue(row, "Name"); // これは null を表示するはずです。 Console.ReadLine(); } private static void Table_RowChanged(object sender, DataRowChangeEventArgs e) { if (e.Action == DataRowAction.Change) { Console.WriteLine($"Row changed: {e.Row["Name", DataRowVersion.Original]} => {e.Row["Name", DataRowVersion.Current]}"); } } private static void PrintOldValue(DataRow row, string columnName) { object oldValue = row[columnName, DataRowVersion.Original]; Console.WriteLine($"Old value of {columnName}: {oldValue}"); }}```このサンプルでは、DataTableに1つの行を追加し、その行の変更を監視します。変更が行われると、`Table_RowChanged`メソッドが呼び出され、変更前の値と変更後の値が表示されます。また、`PrintOldValue`メソッドを使用して、特定の列の古い値を取得して表示します。DataRowの状態が変更され、AcceptChangesメソッドが呼び出されると、古い値はnullになります。
2024.03.14
以下は、C#とWPFを使用してMVVMパターンでOracleからデータを取得して表示するサンプルコードです。この例では、Oracleデータベースから従業員の情報を取得し、WPFのデータグリッドに表示します。まず、Oracleデータベースからデータを取得するためのヘルパークラスを作成します。```csharpusing System;using System.Collections.ObjectModel;using Oracle.ManagedDataAccess.Client;public static class OracleDataAccessHelper{ private static string connectionString = "your_connection_string_here"; public static ObservableCollection<Employee> GetEmployees() { ObservableCollection<Employee> employees = new ObservableCollection<Employee>(); using (OracleConnection connection = new OracleConnection(connectionString)) { string query = "SELECT * FROM Employees"; OracleCommand command = new OracleCommand(query, connection); try { connection.Open(); OracleDataReader reader = command.ExecuteReader(); while (reader.Read()) { employees.Add(new Employee { EmployeeId = reader["EmployeeId"].ToString(), FirstName = reader["FirstName"].ToString(), LastName = reader["LastName"].ToString(), // Add more properties as needed }); } reader.Close(); } catch (Exception ex) { // Handle exception } } return employees; }}```次に、`Employee`クラスを作成します。これは、従業員のデータを表す単純なPOCO(Plain Old CLR Object)です。```csharppublic class Employee{ public string EmployeeId { get; set; } public string FirstName { get; set; } public string LastName { get; set; } // Add more properties as needed}```次に、ビューモデルクラスを作成します。```csharpusing System.Collections.ObjectModel;public class MainViewModel : ViewModelBase{ private ObservableCollection<Employee> employees; public ObservableCollection<Employee> Employees { get { return employees; } set { employees = value; OnPropertyChanged(nameof(Employees)); } } public MainViewModel() { Employees = OracleDataAccessHelper.GetEmployees(); }}```そして、XAMLファイルでビューを作成します。```xml<Window x:Class="OracleDataExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:OracleDataExample" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800"> <Window.DataContext> <local:MainViewModel/> </Window.DataContext> <Grid> <DataGrid ItemsSource="{Binding Employees}" AutoGenerateColumns="True"/> </Grid></Window>```このコードでは、Oracleデータベースから取得した従業員のデータがWPFのデータグリッドに表示されます。データの取得はビューモデルのコンストラクタで行われ、ビューモデルはデータグリッドに表示するデータを保持します。
2024.03.14
以下は、C#とWPFを使用してMVVMパターンで`IDataErrorInfo`を利用するサンプルコードです。この例では、`Person`クラスのバリデーションに`IDataErrorInfo`を使用します。`Person`クラスには、名前と年齢のプロパティがあり、それぞれのプロパティに対して簡単なバリデーションを追加します。まず、`Person`クラスを作成します。```csharpusing System;using System.ComponentModel;public class Person : IDataErrorInfo{ private string name; public string Name { get { return name; } set { name = value; } } private int age; public int Age { get { return age; } set { age = value; } } public string this[string columnName] { get { string result = null; if (columnName == "Name") { if (string.IsNullOrWhiteSpace(Name)) result = "名前は必須です。"; } else if (columnName == "Age") { if (Age < 0 || Age > 120) result = "年齢は0から120の間でなければなりません。"; } return result; } } public string Error => null;}```次に、ビューモデルクラスを作成します。このビューモデルでは、`Person`オブジェクトをプロパティとして持ち、バリデーションエラーメッセージを表示します。```csharpusing System.ComponentModel;using System.Windows;public class MainViewModel : ViewModelBase{ private Person person; public Person Person { get { return person; } set { person = value; OnPropertyChanged(nameof(Person)); } } public MainViewModel() { Person = new Person(); } public ICommand SaveCommand => new RelayCommand(Save, () => Person != null && string.IsNullOrWhiteSpace((Person as IDataErrorInfo).Error)); private void Save() { MessageBox.Show("保存されました。"); }}```最後に、XAMLファイルでビューを作成します。```xml<Window x:Class="ValidationExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:ValidationExample" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800"> <Window.DataContext> <local:MainViewModel/> </Window.DataContext> <Grid> <Grid.RowDefinitions> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> </Grid.RowDefinitions> <Label Content="名前:" Grid.Row="0"/> <TextBox Text="{Binding Person.Name, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" Grid.Row="0"/> <TextBlock Text="{Binding Person[Name], ValidatesOnDataErrors=True}" Foreground="Red" Grid.Row="1"/> <Label Content="年齢:" Grid.Row="2"/> <TextBox Text="{Binding Person.Age, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" Grid.Row="2"/> <TextBlock Text="{Binding Person[Age], ValidatesOnDataErrors=True}" Foreground="Red" Grid.Row="3"/> <Button Content="保存" Command="{Binding SaveCommand}" Grid.Row="4"/> </Grid></Window>```このコードでは、`TextBox`のバインディングに`ValidatesOnDataErrors=True`を指定し、`TextBlock`にはバリデーションエラーメッセージが表示されるようにしています。また、保存ボタンの有効/無効状態は、`SaveCommand`の実行可能性に基づいて制御されています。
2024.03.14
以下は、C#とWPFを使用した基本的なMVVMパターンのサンプルコードです。この例では、簡単なToDoリストアプリケーションを作成します。ToDoアイテムを追加し、削除できるようにします。まず、`ToDoItem`というクラスを作成します。これはToDoアイテムのデータを表します。```csharppublic class ToDoItem{ public string Task { get; set; }}```次に、ビューモデルクラスを作成します。```csharpusing System.Collections.ObjectModel;using System.Windows.Input;using System.Windows;public class MainViewModel : ViewModelBase{ public ObservableCollection<ToDoItem> ToDoItems { get; set; } public ICommand AddCommand { get; set; } public ICommand RemoveCommand { get; set; } private string _newTask; public string NewTask { get { return _newTask; } set { _newTask = value; OnPropertyChanged(nameof(NewTask)); } } public MainViewModel() { ToDoItems = new ObservableCollection<ToDoItem>(); AddCommand = new RelayCommand(AddTask); RemoveCommand = new RelayCommand(RemoveTask); } private void AddTask() { if (!string.IsNullOrWhiteSpace(NewTask)) { ToDoItems.Add(new ToDoItem { Task = NewTask }); NewTask = string.Empty; } } private void RemoveTask(object obj) { var item = obj as ToDoItem; if (item != null) { ToDoItems.Remove(item); } }}````ViewModelBase`は、`INotifyPropertyChanged`を実装する基本クラスです。`RelayCommand`は、`ICommand`を実装し、ビューからビューモデルのコマンドをバインディングするための便利なクラスです。これらのクラスは、通常、MVVMライブラリから取得できます。ビューモデルクラスで使用されている`RelayCommand`の実装例は以下の通りです。```csharpusing System;using System.Windows.Input;public class RelayCommand : ICommand{ private readonly Action _execute; private readonly Func<bool> _canExecute; public RelayCommand(Action execute, Func<bool> canExecute = null) { _execute = execute ?? throw new ArgumentNullException(nameof(execute)); _canExecute = canExecute; } public bool CanExecute(object parameter) { return _canExecute == null || _canExecute(); } public void Execute(object parameter) { _execute(); } public event EventHandler CanExecuteChanged { add { CommandManager.RequerySuggested += value; } remove { CommandManager.RequerySuggested -= value; } }}```最後に、XAMLファイルでビューを作成します。```xml<Window x:Class="ToDoList.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:ToDoList" mc:Ignorable="d" Title="ToDo List" Height="450" Width="800"> <Window.DataContext> <local:MainViewModel/> </Window.DataContext> <Grid> <Grid.RowDefinitions> <RowDefinition Height="Auto"/> <RowDefinition Height="*"/> </Grid.RowDefinitions> <StackPanel Grid.Row="0" Orientation="Horizontal"> <TextBox Width="200" Margin="5" Text="{Binding NewTask, UpdateSourceTrigger=PropertyChanged}"/> <Button Width="80" Margin="5" Content="Add" Command="{Binding AddCommand}"/> </StackPanel> <ListBox Grid.Row="1" ItemsSource="{Binding ToDoItems}" DisplayMemberPath="Task"> <ListBox.ItemTemplate> <DataTemplate> <StackPanel Orientation="Horizontal"> <TextBlock Text="{Binding Task}"/> <Button Content="Remove" Command="{Binding DataContext.RemoveCommand, RelativeSource={RelativeSource AncestorType=ListBox}}" CommandParameter="{Binding}"/> </StackPanel> </DataTemplate> </ListBox.ItemTemplate> </ListBox> </Grid></Window>```これで、基本的なMVVMパターンを使用したToDoリストアプリケーションが完成しました。ビューはXAMLで定義され、ビューモデルはコードビハインドから分離されます。ビューとビューモデルは、データバインディングとコマンドバインディングを使用して相互に通信します。
2024.03.14
MVVM(Model-View-ViewModel)は、ソフトウェアアーキテクチャのパターンの一つであり、特にC#やWPF(Windows Presentation Foundation)などのXAMLベースのアプリケーションで広く使用されています。MVVMは、UI(ユーザーインターフェース)のロジックをモデルから分離し、それをビューとビューモデルに分割することで、アプリケーションの保守性やテスト容易性を向上させます。MVVMの3つの主要なコンポーネントは次の通りです:1. **モデル(Model)**: モデルは、アプリケーションのデータやビジネスロジックを表します。これは、データベースからのデータ、ファイルからのデータ、APIからのデータなど、アプリケーションで扱うデータ全般を指します。2. **ビュー(View)**: ビューは、ユーザーインターフェースの外観やレイアウトを表します。これは、XAML(WPFの場合)で定義され、ユーザーが見ることができる部分です。ビューは、UIの状態を反映するためにビューモデルと連携します。3. **ビューモデル(ViewModel)**: ビューモデルは、ビューとモデルの間の中間層として機能し、ビューとモデルの間の通信を処理します。具体的には、ビューに表示されるデータやビジネスロジックを提供し、ビューからのユーザーの操作をモデルに転送します。ビューモデルは通常、INotifyPropertyChangedなどのデータバインディングをサポートし、ビューとの双方向のデータバインディングを実現します。MVVMの利点は多岐にわたりますが、主なものは以下の通りです:- **分離された責務**: MVVMは、UIロジック、ビジネスロジック、データを明確に分離するため、コードの保守性が向上します。- **テスト容易性**: ビューモデルがビジネスロジックをカプセル化しているため、単体テストが容易に行えます。また、ビューはUIの外観とレイアウトに関する責務しか持たないため、テストが容易になります。- **データバインディングのサポート**: MVVMは、WPFなどのXAMLベースのテクノロジーにおけるデータバインディングをサポートしており、ビューとビューモデルの間でのデータの同期を効率的に行うことができます。- **コードの再利用性**: ビューモデルはビジネスロジックを含むため、異なるビューで同じビジネスロジックを再利用することができます。MVVMを実装するには、XAMLを使用してビューを作成し、C#などのプログラミング言語を使用してビューモデルとモデルを作成します。ビューとビューモデルの間の通信は、データバインディングなどのメカニズムを使用して行われます。MVVMを使用すると、UIの複雑さを管理しやすくし、柔軟性を高めることができます。
2024.03.14
多言語化をサポートするために、C# WPF アプリケーションでリソースファイルを使用する方法を示します。この方法では、異なる言語ごとに異なるリソースファイルを作成し、それらをアプリケーションで動的に切り替えます。まず、リソースファイルを作成します。Visual Studio のプロジェクトエクスプローラーで、`Resources` フォルダを右クリックし、`追加` > `新しい項目` を選択します。その後、`.resx` ファイルを追加します。例えば、`Strings.resx` という名前のリソースファイルを作成します。このファイルにはデフォルトの言語のリソースが含まれます。次に、他の言語のリソースファイルを作成します。例えば、日本語の場合は `Strings.ja-JP.resx`、スペイン語の場合は `Strings.es-ES.resx` といった具合です。これらのファイルには、各言語に対応するテキストリソースが含まれます。リソースファイルにキーと値を追加します。例えば、キーを `WelcomeMessage` とし、値を `Welcome to our application!` とします。同様に、他の言語のリソースファイルにも同じキーとその言語に対応する値を追加します。次に、WPF の XAML ファイルでリソースを使用します。例えば、`MainWindow.xaml` ファイルの場合、次のようにします。```xml<Window x:Class="WpfApp.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:WpfApp" Title="MainWindow" Height="450" Width="800"> <Grid> <TextBlock Text="{x:Static local:Resources.WelcomeMessage}" HorizontalAlignment="Center" VerticalAlignment="Center"/> </Grid></Window>```ここで、`local:Resources.WelcomeMessage` はリソースファイルで定義された `WelcomeMessage` キーに対応する値を表示するために使用されます。最後に、言語を切り替えるための機能を実装します。ユーザーが言語を切り替える際に、アプリケーションのカルチャを変更し、適切なリソースファイルが読み込まれるようにします。これには、`Thread.CurrentThread.CurrentCulture` と `Thread.CurrentThread.CurrentUICulture` プロパティを使用します。
2024.03.13
ASP.NET MVC パターンで入力チェックを実施するサンプルコードを示します。ここでは、モデルの属性を使用して入力検証を行います。まず、モデルを定義します。```csharpusing System.ComponentModel.DataAnnotations;namespace MvcValidationExample.Models{ public class User { [Required(ErrorMessage = "名前を入力してください")] public string Name { get; set; } [EmailAddress(ErrorMessage = "正しいメールアドレスを入力してください")] public string Email { get; set; } [Range(18, 120, ErrorMessage = "年齢は18歳以上120歳以下である必要があります")] public int Age { get; set; } }}```次に、コントローラーでアクションメソッドを定義します。```csharpusing System.Web.Mvc;using MvcValidationExample.Models;namespace MvcValidationExample.Controllers{ public class UserController : Controller { public ActionResult Create() { return View(); } [HttpPost] public ActionResult Create(User user) { if (ModelState.IsValid) { // モデルが検証を通過した場合の処理 return RedirectToAction("Index", "Home"); } // モデルが検証エラーの場合、入力フォームを再表示 return View(user); } }}```最後に、ビューを作成します。Create.cshtml:```html@model MvcValidationExample.Models.User@using (Html.BeginForm()){ @Html.ValidationSummary(true) <div> @Html.LabelFor(model => model.Name) @Html.EditorFor(model => model.Name) @Html.ValidationMessageFor(model => model.Name) </div> <div> @Html.LabelFor(model => model.Email) @Html.EditorFor(model => model.Email) @Html.ValidationMessageFor(model => model.Email) </div> <div> @Html.LabelFor(model => model.Age) @Html.EditorFor(model => model.Age) @Html.ValidationMessageFor(model => model.Age) </div> <button type="submit">Submit</button>}```このサンプルでは、モデルの各プロパティに入力検証のルールを定義しました。コントローラーのアクションメソッドでは、`ModelState.IsValid` プロパティを使用して、モデルの入力検証が成功したかどうかを確認しています。入力検証が成功した場合は処理を継続し、失敗した場合は入力フォームを再表示します。ビューでは、`@Html.ValidationMessageFor()` ヘルパーメソッドを使用してエラーメッセージを表示します。
2024.03.13
ASP.NET MVC フレームワークでは、ボタンクリック時にコントローラークラスのメソッドを呼び出すために、通常はフォームの送信を使用してアクションメソッドをトリガーします。以下に、ASP.NET MVC でボタンクリック時にコントローラーのアクションメソッドを呼び出すサンプルコードを示します。まず、ビューでボタンを定義します。```html@using (Html.BeginForm("Test", "ControllerName", FormMethod.Post)){ <button type="submit">Click me</button>}```次に、コントローラーで Test アクションメソッドを定義します。```csharpusing System.Web.Mvc;namespace YourNamespace.Controllers{ public class YourController : Controller { public ActionResult Test() { // Testメソッドの処理 return View(); } }}```このコードでは、ビューでフォームを開始し、そのフォームが ControllerName コントローラーの Test アクションメソッドを呼び出すように設定しています。ボタンがクリックされると、フォームが送信され、指定されたコントローラーの指定されたアクションメソッドが呼び出されます。
2024.03.13
ASP.NET ボタンをクリックした際に Test.asp を表示するためのサンプルコードは以下の通りです。```html<asp:Button ID="btnRedirect" runat="server" Text="Redirect" OnClick="btnRedirect_Click" />``````csharpprotected void btnRedirect_Click(object sender, EventArgs e){ Response.Redirect("Test.asp");}```このサンプルでは、ASP.NET のボタンコントロールを使用してボタンを作成し、そのクリックイベントに対してサーバーサイドのイベントハンドラーを設定しています。ボタンがクリックされたときに、`btnRedirect_Click` メソッドが実行され、`Response.Redirect` メソッドを使用して Test.asp にリダイレクトされます。
2024.03.13
ASP.NET MVC アプリケーションでよく利用される JavaScript ライブラリには、以下のようなものがあります。1. **jQuery**: DOM 操作やイベント処理などの基本的な JavaScript 機能を簡略化するためのライブラリです。ASP.NET MVC のビューでよく使用されます。2. **Bootstrap**: レスポンシブ Web デザインの構築や UI コンポーネントの整備に役立つフレームワークです。ASP.NET MVC アプリケーションの UI を整えるために利用されます。3. **AngularJS / Angular**: クライアントサイドの MVC フレームワークであり、データバインディングやルーティングなどの機能を提供します。特に AngularJS は、古い ASP.NET MVC プロジェクトでよく使用されます。4. **React**: ユーザーインターフェースの構築や管理をするための JavaScript ライブラリであり、仮想 DOM を使用して高速なレンダリングを実現します。ASP.NET MVC プロジェクトでフロントエンド開発を行う場合に使用されることがあります。5. **Vue.js**: データバインディングやコンポーネントベースのアーキテクチャを提供する JavaScript フレームワークであり、軽量で柔軟なフレームワークとして人気があります。ASP.NET MVC と組み合わせて利用されることがあります。これらの JavaScript ライブラリやフレームワークは、ASP.NET MVC アプリケーションのクライアントサイド開発を効率化し、モダンな UI を実装するために利用されます。それぞれのライブラリやフレームワークには独自の特徴や利点がありますので、プロジェクトの要件や開発チームのスキルに応じて選択することが重要です。
2024.03.13
`ViewBag` は、ASP.NET MVC および ASP.NET Core MVC で使用される動的なバッグオブジェクトです。ViewBag を使用すると、コントローラーからビューにデータを動的に渡すことができます。ViewBag は、動的型のプロパティを持つオブジェクトであり、そのプロパティはビュー内で参照されることができます。主な機能と役割は次の通りです:1. **データの渡し方**: ViewBag を使用すると、コントローラーで生成されたデータをビューに渡すことができます。これにより、ビューが表示するデータをコントローラーから動的に指定できます。2. **動的なプロパティ**: ViewBag は動的型を使用しているため、ビュー内でプロパティを定義することができます。コントローラー内で ViewBag に追加したプロパティは、ビュー内で直接参照することができます。3. **動的なビューの変更**: ViewBag を使用すると、ビューの動的な変更を容易に行うことができます。コントローラー内で条件や状態に応じて異なるデータを ViewBag にセットし、ビュー内でそれを適切に表示することができます。例えば、コントローラー内で次のように ViewBag を使用してデータをセットできます。```csharppublic ActionResult Index(){ ViewBag.Message = "Welcome to my website!"; ViewBag.UserName = User.Identity.Name; return View();}```そして、ビュー内で ViewBag のプロパティを参照することができます。```html<h2>@ViewBag.Message</h2><p>Hello, @ViewBag.UserName!</p>```このように、ViewBag を使用すると、ビュー内で簡単にコントローラーから渡されたデータを表示することができます。ただし、ViewBag は動的型を使用しているため、型安全性がないため、誤ったプロパティ名を指定した場合には実行時エラーが発生する可能性があります。そのため、可能な限りビューモデルや強く型付けされたビューにデータを渡す方が望ましい場合があります。
2024.03.13
以下は、ASP.NET MVC でよく利用される Razor 構文のサンプルコードです。1. 条件文の使用:```html@if (User.Identity.IsAuthenticated){ <p>Welcome, @User.Identity.Name!</p>}else{ <p>Please log in to access this page.</p>}```2. ループ文の使用:```html<ul> @foreach (var item in Model) { <li>@item.Name</li> }</ul>```3. ビューバッグの使用:```html<h2>@ViewBag.Message</h2>```4. リンクの生成:```html<a href="@Url.Action("ActionName", "ControllerName")">Link</a>```5. HTML ヘルパーの使用:```html@Html.TextBox("Name")```これらのサンプルでは、Razor 構文を使用して C# コードを HTML テンプレートに組み込んでいます。条件文、ループ文、ビューバッグ、リンク生成、HTML ヘルパーなど、Razor 構文は ASP.NET MVC アプリケーションで強力なツールとして使用されます。
2024.03.13
`@{ ... }` は、Razor 構文で C# コードを記述するためのブロックです。このブロック内には、C# コードや Razor コードを記述することができます。`ViewBag` は、ASP.NET MVC でビューとコントローラー間でデータをやり取りするための動的なバッグです。`ViewBag.Title` は、ビューに表示されるタイトルを指定するためのプロパティです。この行では、ビューのタイトルを "Home Page" に設定しています。`ViewBag.Title` に設定された値は、ビュー内で `@ViewBag.Title` のようにして参照できます。これにより、ビューに表示されるページのタイトルを動的に変更することができます。
2024.03.13
以下は、ASP.NET MVC パターンでシンプルなサンプルコードです。この例では、コントローラーが "Hello World" メッセージをビューに渡して表示します。まず、コントローラーを作成します。```csharpusing System.Web.Mvc;namespace MvcSimpleExample.Controllers{ public class HomeController : Controller { public ActionResult Index() { ViewBag.Message = "Hello World!"; return View(); } }}```次に、ビューを作成します。Index.cshtml:```html@{ ViewBag.Title = "Home Page";}<h2>@ViewBag.Message</h2>```このビューは、コントローラーから受け取った "Hello World" メッセージを表示します。以上で、ASP.NET MVC パターンのシンプルなサンプルが完成しました。コントローラーはビジネスロジックを処理し、ビューはユーザーインターフェースを表示します。データはコントローラーからビューに渡されます。
2024.03.13
以下は、ASP.NET MVC パターンでデータを新規追加するサンプルコードです。まず、モデルを定義します。```csharpusing System.ComponentModel.DataAnnotations;namespace MvcAddExample.Models{ public class Item { public int Id { get; set; } [Required] public string Name { get; set; } }}```次に、コントローラーを作成します。```csharpusing System.Collections.Generic;using System.Linq;using System.Web.Mvc;using MvcAddExample.Models;namespace MvcAddExample.Controllers{ public class ItemController : Controller { private static readonly List<Item> items = new List<Item> { new Item { Id = 1, Name = "Item 1" }, new Item { Id = 2, Name = "Item 2" }, new Item { Id = 3, Name = "Item 3" } }; // 一覧表示アクション public ActionResult Index() { return View(items); } // 新規追加画面表示アクション public ActionResult Create() { return View(); } // 追加アクション [HttpPost] public ActionResult Create(Item item) { if (ModelState.IsValid) { int newId = items.Max(i => i.Id) + 1; item.Id = newId; items.Add(item); return RedirectToAction("Index"); } return View(item); } }}```このコントローラーは、`Item` モデルの一覧表示、新規追加画面表示、データ追加を提供します。`Index` アクションは、`items` リストをビューに渡して表示します。`Create` アクションは、新規アイテムのフォームを表示します。`HttpPost` 属性が付いた `Create` アクションは、フォームから送信されたデータを受け取り、新しいアイテムをリストに追加して一覧ページにリダイレクトします。最後に、ビューを作成します。Index.cshtml:```html@model IEnumerable<MvcAddExample.Models.Item><table> <tr> <th>ID</th> <th>Name</th> </tr> @foreach (var item in Model) { <tr> <td>@item.Id</td> <td>@item.Name</td> </tr> }</table>@Html.ActionLink("Create New", "Create")```Create.cshtml:```html@model MvcAddExample.Models.Item@using (Html.BeginForm()){ @Html.ValidationSummary(true) <div> @Html.LabelFor(model => model.Name) @Html.TextBoxFor(model => model.Name) @Html.ValidationMessageFor(model => model.Name) </div> <button type="submit">Create</button>}```このビューは、`Item` モデルの一覧を表示し、新規追加リンクを提供します。新規追加画面では、新しいアイテムの名前を入力し、作成ボタンをクリックすることでデータが追加されます。このサンプルでは、MVC パターンの原則に従っています。ビューはユーザーインターフェイスを表示し、コントローラーはビジネスロジックを処理し、モデルはデータを表現します。
2024.03.13
以下は、ASP.NET MVC パターンでデータを更新するサンプルコードです。まず、モデルを定義します。```csharpusing System.ComponentModel.DataAnnotations;namespace MvcUpdateExample.Models{ public class Item { public int Id { get; set; } [Required] public string Name { get; set; } }}```次に、コントローラーを作成します。```csharpusing System.Collections.Generic;using System.Linq;using System.Web.Mvc;using MvcUpdateExample.Models;namespace MvcUpdateExample.Controllers{ public class ItemController : Controller { private static readonly List<Item> items = new List<Item> { new Item { Id = 1, Name = "Item 1" }, new Item { Id = 2, Name = "Item 2" }, new Item { Id = 3, Name = "Item 3" } }; // 一覧表示アクション public ActionResult Index() { return View(items); } // 編集画面表示アクション public ActionResult Edit(int id) { var item = items.FirstOrDefault(i => i.Id == id); if (item == null) { return HttpNotFound(); } return View(item); } // 更新アクション [HttpPost] public ActionResult Edit(Item item) { if (ModelState.IsValid) { var existingItem = items.FirstOrDefault(i => i.Id == item.Id); if (existingItem != null) { existingItem.Name = item.Name; } return RedirectToAction("Index"); } return View(item); } }}```このコントローラーは、`Item` モデルの一覧表示、編集画面表示、データ更新を提供します。`Index` アクションは、`items` リストをビューに渡して表示します。`Edit` アクションは、指定された ID のアイテムを編集するためのフォームを表示します。`HttpPost` 属性が付いた `Edit` アクションは、フォームから送信されたデータを受け取り、モデルを更新して一覧ページにリダイレクトします。最後に、ビューを作成します。Index.cshtml:```html@model IEnumerable<MvcUpdateExample.Models.Item><table> <tr> <th>ID</th> <th>Name</th> <th></th> </tr> @foreach (var item in Model) { <tr> <td>@item.Id</td> <td>@item.Name</td> <td>@Html.ActionLink("Edit", "Edit", new { id = item.Id })</td> </tr> }</table>```Edit.cshtml:```html@model MvcUpdateExample.Models.Item@using (Html.BeginForm()){ @Html.ValidationSummary(true) <div> @Html.LabelFor(model => model.Name) @Html.TextBoxFor(model => model.Name) @Html.ValidationMessageFor(model => model.Name) </div> <button type="submit">Save</button>}```このビューは、`Item` モデルの一覧を表示し、各アイテムに対して編集リンクを提供します。編集画面では、アイテムの名前を編集し、保存ボタンをクリックすることでデータが更新されます。このサンプルでは、MVC パターンの原則に従っています。ビューはユーザーインターフェイスを表示し、コントローラーはビジネスロジックを処理し、モデルはデータを表現します。
2024.03.13
ASP.NET MVC パターンで削除機能を実装するサンプルコードとその解説を以下に示します。まず、モデルを定義します。```csharpusing System.ComponentModel.DataAnnotations;namespace MvcDeleteExample.Models{ public class Item { public int Id { get; set; } [Required] public string Name { get; set; } }}```次に、コントローラーを作成します。```csharpusing System.Linq;using System.Web.Mvc;using MvcDeleteExample.Models;namespace MvcDeleteExample.Controllers{ public class ItemController : Controller { private static readonly List<Item> items = new List<Item> { new Item { Id = 1, Name = "Item 1" }, new Item { Id = 2, Name = "Item 2" }, new Item { Id = 3, Name = "Item 3" } }; // 一覧表示アクション public ActionResult Index() { return View(items); } // 削除アクション public ActionResult Delete(int id) { var item = items.FirstOrDefault(i => i.Id == id); if (item != null) { items.Remove(item); } return RedirectToAction("Index"); } }}```このコントローラーは、`Item` モデルの一覧表示と削除機能を提供します。`Index` アクションは、`items` リストをビューに渡して表示します。`Delete` アクションは、指定された ID のアイテムを削除し、一覧ページにリダイレクトします。最後に、ビューを作成します。```html@model IEnumerable<MvcDeleteExample.Models.Item><table> <tr> <th>ID</th> <th>Name</th> <th></th> </tr> @foreach (var item in Model) { <tr> <td>@item.Id</td> <td>@item.Name</td> <td>@Html.ActionLink("Delete", "Delete", new { id = item.Id })</td> </tr> }</table>```このビューは、`Item` モデルの一覧を表示し、各アイテムの横に削除リンクを提供します。削除リンクをクリックすると、対応するアイテムが削除されます。解説:1. モデル (`Item`) は単純な ID と名前のプロパティを持ちます。2. コントローラー (`ItemController`) は、モデルの一覧表示と削除機能を提供します。3. ビュー (`Index.cshtml`) は、モデルの一覧を表示し、各アイテムに対して削除リンクを提供します。このサンプルでは、MVC パターンの基本的な原則に従っています。ビューはユーザーインターフェイスを表示し、コントローラーはビジネスロジックを処理し、モデルはデータを表現します。
2024.03.13
以下は、ASP.NET Web Forms でテキストボックスに入力された値を使用して Oracle データベースからデータを検索し、GridView に表示するサンプルコードです。この例では、ADO.NET を使用して Oracle データベースに接続しています。ASP.NET ページのマークアップ:```aspx<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="SearchPage.aspx.cs" Inherits="WebApplication.SearchPage" %><!DOCTYPE html><html xmlns="http://www.w3.org/1999/xhtml"><head runat="server"> <title>Search Page</title></head><body> <form id="form1" runat="server"> <div> <asp:TextBox ID="searchTextBox" runat="server"></asp:TextBox> <asp:Button ID="searchButton" runat="server" Text="Search" OnClick="searchButton_Click" /> <asp:GridView ID="resultGridView" runat="server" AutoGenerateColumns="true"></asp:GridView> </div> </form></body></html>```ASP.NET コードビハインド:```csharpusing System;using System.Data;using Oracle.ManagedDataAccess.Client;namespace WebApplication{ public partial class SearchPage : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { // 初回ロード時の処理 } } protected void searchButton_Click(object sender, EventArgs e) { string connectionString = "Your Oracle Connection String"; // Oracle データベース接続文字列を指定します string searchValue = searchTextBox.Text; using (OracleConnection connection = new OracleConnection(connectionString)) { string query = "SELECT * FROM YourTable WHERE YourColumn = :SearchValue"; // パラメータ化された SQL クエリを指定します OracleDataAdapter adapter = new OracleDataAdapter(query, connection); adapter.SelectCommand.Parameters.Add(":SearchValue", OracleDbType.Varchar2).Value = searchValue; DataTable dataTable = new DataTable(); adapter.Fill(dataTable); resultGridView.DataSource = dataTable; resultGridView.DataBind(); } } }}```このコードでは、`searchButton_Click` イベントハンドラーがテキストボックスに入力された値を使用して Oracle データベースからデータを検索します。接続文字列とクエリは適切に設定する必要があります。そして、GridView のデータソースに検索結果をバインドして表示しています。
2024.03.13
以下は、ASP.NET Web アプリケーションで Oracle データベースからデータを取得し、GridView に表示するサンプルコードです。この例では、Oracle の接続に Oracle Data Provider for .NET (ODP.NET) を使用します。まず、Oracle データベースへの接続とデータの取得を行うメソッドを作成します。```csharpusing Oracle.ManagedDataAccess.Client;using System;using System.Configuration;using System.Data;using System.Web.UI.WebControls;public class OracleDataProvider{ private string connectionString = ConfigurationManager.ConnectionStrings["OracleConnectionString"].ConnectionString; public DataTable GetOracleData() { DataTable dataTable = new DataTable(); using (OracleConnection connection = new OracleConnection(connectionString)) { string query = "SELECT * FROM YourTableName"; // テーブル名を適切に指定してください using (OracleCommand command = new OracleCommand(query, connection)) { connection.Open(); using (OracleDataReader reader = command.ExecuteReader()) { dataTable.Load(reader); } } } return dataTable; }}```このクラスでは、Oracle データベースからデータを取得する `GetOracleData` メソッドが定義されています。接続文字列は `Web.config` ファイルから取得します。次に、ASP.NET ページに GridView を追加し、Oracle データベースから取得したデータを表示します。```aspx<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="OracleGridViewExample._Default" %><!DOCTYPE html><html xmlns="http://www.w3.org/1999/xhtml"><head runat="server"> <title></title></head><body> <form id="form1" runat="server"> <div> <asp:GridView ID="GridView1" runat="server"></asp:GridView> </div> </form></body></html>```最後に、Code-Behind ファイルで Oracle データベースからデータを取得し、GridView にバインドします。```csharpusing System;using System.Data;using System.Web.UI.WebControls;namespace OracleGridViewExample{ public partial class _Default : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { OracleDataProvider oracleDataProvider = new OracleDataProvider(); DataTable dataTable = oracleDataProvider.GetOracleData(); GridView1.DataSource = dataTable; GridView1.DataBind(); } } }}```これで、Oracle データベースから取得したデータが GridView に表示されます。必要に応じて、GridView の列をカスタマイズしたり、ページングやソート機能を追加したりすることができます。
2024.03.13
ASP.NET でよく使用されるコントロールには、次のようなものがあります。1. **TextBox**: ユーザーからのテキスト入力を受け付けるためのコントロール。2. **Button**: クリックされることで何らかのアクションをトリガーするためのコントロール。3. **Label**: ページ上にテキストを表示するためのコントロール。4. **DropDownList**: ユーザーに選択肢を提供し、選択された項目を取得するためのコントロール。5. **CheckBox**: ユーザーにチェックボックスの選択肢を提供し、選択された項目を取得するためのコントロール。6. **RadioButton**: ユーザーにラジオボタンの選択肢を提供し、選択された項目を取得するためのコントロール。7. **GridView**: データを表形式で表示し、編集やソート、ページングなどの機能を提供するためのコントロール。8. **DataList**: データをリピーターとして表示するためのコントロール。9. **Repeater**: データをテンプレートとして繰り返し表示するためのコントロール。10. **Calendar**: カレンダーを表示し、日付の選択を可能にするためのコントロール。これらのコントロールは、ASP.NET Web アプリケーションで広く使用されており、ユーザーインターフェイスの構築やデータの表示に役立ちます。また、多くの場合、これらのコントロールはサーバーサイドで制御され、ユーザーとのインタラクションやデータの処理を行います。
2024.03.13
以下は、C# WPF の MVVM パターンで `INotifyPropertyChanged` を使用するサンプルコードです。```csharpusing System.ComponentModel;using System.Windows.Input;namespace MVVMExample{ public class MainViewModel : INotifyPropertyChanged { private string _name; public string Name { get { return _name; } set { if (_name != value) { _name = value; OnPropertyChanged(nameof(Name)); } } } private ICommand _sayHelloCommand; public ICommand SayHelloCommand { get { if (_sayHelloCommand == null) { _sayHelloCommand = new RelayCommand( param => SayHello(), param => !string.IsNullOrEmpty(Name) ); } return _sayHelloCommand; } } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } private void SayHello() { // ここで名前を使って挨拶を表示するロジックを実装します // このサンプルでは単純にコンソールに挨拶を表示します Console.WriteLine($"Hello, {Name}!"); } }}```この `MainViewModel` クラスは、`INotifyPropertyChanged` インターフェースを実装しています。`Name` プロパティは、プロパティが変更されるたびに `OnPropertyChanged` メソッドを呼び出すように実装されています。また、`SayHelloCommand` プロパティは、`ICommand` インターフェースを実装しています。これは、ユーザーが名前を入力し、「Hello」ボタンをクリックしたときに呼び出されるメソッドを提供します。`RelayCommand` は、前の回答で示したように、`ICommand` インターフェースを実装するカスタムコマンドクラスです。この ViewModel を使用して、WPF の View とバインドしてデータとコマンドを操作することができます。
2024.03.13
MVVM パターンで `ICommand` を使用するサンプルコードを以下に示します。まず、`RelayCommand` クラスを定義します。```csharpusing System;using System.Windows.Input;namespace MVVMSample{ public class RelayCommand : ICommand { private readonly Action<object> _execute; private readonly Func<object, bool> _canExecute; public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null) { _execute = execute ?? throw new ArgumentNullException(nameof(execute)); _canExecute = canExecute; } public event EventHandler CanExecuteChanged { add { CommandManager.RequerySuggested += value; } remove { CommandManager.RequerySuggested -= value; } } public bool CanExecute(object parameter) { return _canExecute == null || _canExecute(parameter); } public void Execute(object parameter) { _execute(parameter); } }}```次に、ViewModel を定義します。```csharpusing System.ComponentModel;using System.Windows.Input;namespace MVVMSample{ public class MainViewModel : INotifyPropertyChanged { private string _message; public string Message { get { return _message; } set { if (_message != value) { _message = value; OnPropertyChanged(nameof(Message)); } } } public ICommand ShowMessageCommand { get; } public MainViewModel() { ShowMessageCommand = new RelayCommand(ShowMessage); } private void ShowMessage(object obj) { Message = "Hello, MVVM!"; } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } }}```最後に、View を定義します。```xml<Window x:Class="MVVMSample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:MVVMSample" Title="MVVM Sample" Height="150" Width="300"> <Window.DataContext> <local:MainViewModel/> </Window.DataContext> <Grid> <Button Content="Show Message" Command="{Binding ShowMessageCommand}" Margin="10"/> <TextBlock Text="{Binding Message}" Margin="10" VerticalAlignment="Center" HorizontalAlignment="Center"/> </Grid></Window>```このサンプルでは、`RelayCommand` を使用して `ICommand` を実装し、ViewModel 内で `ShowMessageCommand` を定義しています。`ShowMessageCommand` は、`ShowMessage` メソッドを実行するためのコマンドです。View では、`Button` の `Command` プロパティに `ShowMessageCommand` をバインドしています。これにより、`Button` をクリックすると `ShowMessage` メソッドが実行され、ViewModel の `Message` プロパティが更新されます。View では、`TextBlock` の `Text` プロパティに `Message` プロパティをバインドして、表示される内容が更新されます。
2024.03.13
C# WPF アプリケーションでリソースファイルにテンプレートを記述して読み込む方法を説明します。まず、WPF のリソースファイルにテンプレートを定義します。これを行うには、`ResourceDictionary` を使用します。この例では、`Window.Resources` セクションにテンプレートを定義します。```xml<Window x:Class="WpfApp.ResourceDictionaryExample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="450" Width="800"> <Window.Resources> <ResourceDictionary> <ControlTemplate x:Key="MyButtonTemplate" TargetType="Button"> <Border Background="LightBlue" BorderBrush="Black" BorderThickness="1" CornerRadius="5" Padding="5"> <TextBlock Text="{TemplateBinding Content}" Foreground="White" HorizontalAlignment="Center" VerticalAlignment="Center"/> </Border> </ControlTemplate> </ResourceDictionary> </Window.Resources> <Grid> <Button Template="{StaticResource MyButtonTemplate}" Content="Click Me"/> </Grid></Window>```この例では、`ControlTemplate` を使用して `MyButtonTemplate` というキーでテンプレートを定義しています。このテンプレートは、`Button` コントロールの見た目を定義しています。次に、このテンプレートを使用する `Button` を定義します。`Button` の `Template` プロパティに、定義したテンプレートを `StaticResource` を使って指定します。このようにすることで、`Button` は定義したテンプレートのスタイルを適用し、表示される内容がテンプレートに従ってレンダリングされます。この方法を使えば、様々なコントロールや要素に対してカスタムのテンプレートを定義して、リソースファイルから読み込むことができます。
2024.03.13
C# WPF アプリケーションからバッチファイルを実行する方法のサンプルコードを以下に示します。```csharpusing System;using System.Diagnostics;using System.Windows;namespace BatchFileExecutionSample{ public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void Button_Click(object sender, RoutedEventArgs e) { try { // バッチファイルのパスを指定します string batchFilePath = @"C:\path\to\your\batch\file.bat"; // バッチファイルを実行します ProcessStartInfo startInfo = new ProcessStartInfo { FileName = "cmd.exe", Arguments = $"/c \"{batchFilePath}\"", UseShellExecute = false, CreateNoWindow = true }; using (Process process = new Process { StartInfo = startInfo }) { process.Start(); process.WaitForExit(); } MessageBox.Show("Batch file executed successfully."); } catch (Exception ex) { MessageBox.Show($"An error occurred: {ex.Message}"); } } }}```このサンプルでは、`Process` クラスを使用してバッチファイルを実行しています。`ProcessStartInfo` を設定して、`cmd.exe` を実行し、バッチファイルへのパスを引数として渡しています。また、`UseShellExecute` を `false` に設定し、`CreateNoWindow` を `true` に設定して、シェルを使用せずにプロセスを作成し、ウィンドウを表示しないようにしています。必要に応じて、実行中のプロセスを待機したり、エラー処理を追加したりすることができます。
2024.03.13
以下は、C# WPF アプリケーションで `ElementName` を使用して他の要素にバインディングするサンプルコードです。```xml<Window x:Class="ElementNameBindingSample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="150" Width="300"> <Grid> <TextBox x:Name="textBox" Text="Hello"/> <TextBlock Text="{Binding Text, ElementName=textBox}" VerticalAlignment="Center" HorizontalAlignment="Center"/> </Grid></Window>```この例では、`TextBox` に `x:Name="textBox"` を指定しています。次に、`TextBlock` の `Text` プロパティにバインディングを行う際に、`ElementName` を使用して `textBox` の `Text` プロパティにバインドしています。これにより、`TextBlock` は `TextBox` のテキストを表示します。このように、`ElementName` を使用することで、同じ XAML ツリー内の他の要素にバインドすることができます。
2024.03.13
以下は、C# WPF の MVVM パターンを使用したサンプルコードです。この例では、MVVM パターンに基づいて、ユーザーが名前を入力してメッセージを表示する機能を持つシンプルなアプリケーションを示しています。まず、ViewModel を定義します。```csharpusing System.ComponentModel;using System.Windows.Input;namespace MVVMSample{ public class MainViewModel : INotifyPropertyChanged { private string _name; private string _message; public string Name { get { return _name; } set { if (_name != value) { _name = value; OnPropertyChanged(nameof(Name)); } } } public string Message { get { return _message; } set { if (_message != value) { _message = value; OnPropertyChanged(nameof(Message)); } } } public ICommand ShowMessageCommand { get; } public MainViewModel() { ShowMessageCommand = new RelayCommand(ShowMessage); } private void ShowMessage(object obj) { Message = $"Hello, {Name}!"; } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } }}```次に、RelayCommand を定義します。```csharpusing System;using System.Windows.Input;namespace MVVMSample{ public class RelayCommand : ICommand { private readonly Action<object> _execute; private readonly Func<object, bool> _canExecute; public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null) { _execute = execute ?? throw new ArgumentNullException(nameof(execute)); _canExecute = canExecute; } public event EventHandler CanExecuteChanged { add { CommandManager.RequerySuggested += value; } remove { CommandManager.RequerySuggested -= value; } } public bool CanExecute(object parameter) { return _canExecute == null || _canExecute(parameter); } public void Execute(object parameter) { _execute(parameter); } }}```最後に、View を定義します。```xml<Window x:Class="MVVMSample.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:MVVMSample" Title="MVVM Sample" Height="150" Width="300"> <Grid> <StackPanel Margin="10"> <TextBlock Text="Enter your name:"/> <TextBox Text="{Binding Name, UpdateSourceTrigger=PropertyChanged}" Margin="0 5"/> <Button Content="Show Message" Command="{Binding ShowMessageCommand}" Margin="0 10"/> <TextBlock Text="{Binding Message}" Margin="0 10"/> </StackPanel> </Grid></Window>```この例では、ViewModel が `INotifyPropertyChanged` インターフェースを実装しており、`RelayCommand` を使用してコマンドを処理します。View では、`TextBox`、`Button`、`TextBlock` をバインディングして、ViewModel のプロパティとコマンドを使用します。これで、MVVM パターンを使用して簡単な WPF アプリケーションが完成しました。
2024.03.13
全16300件 (16300件中 401-450件目)