「C#」タグの記事が5件件あります

using sampleworker;

var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();

var host = builder.Build();
host.Run();

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            if (_logger.IsEnabled(LogLevel.Information))
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            }
            await Task.Delay(1000, stoppingToken);
        }
    }
}

var builder = Host.CreateApplicationBuilder(args);

public int main(string[] args)
{
}

builder.Services.AddHostedService<Worker>();

var host = builder.Build();

host.Run();

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            if (_logger.IsEnabled(LogLevel.Information))
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            }
            await Task.Delay(1000, stoppingToken);
        }
    }
}

public class Worker : BackgroundService

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

namespace Microsoft.Extensions.Logging
{
    /// <summary>
    /// A generic interface for logging where the category name is derived from the specified
    /// <typeparamref name="TCategoryName"/> type name.
    /// Generally used to enable activation of a named <see cref="ILogger"/> from dependency injection.
    /// </summary>
    /// <typeparam name="TCategoryName">The type whose name is used for the logger category name.</typeparam>
    public interface ILogger<out TCategoryName> : ILogger
    {

    }
}

protected override async Task ExecuteAsync(CancellationToken stoppingToken)

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Extensions.Hosting
{
    /// <summary>
    /// Base class for implementing a long running <see cref="IHostedService"/>.
    /// </summary>
    public abstract class BackgroundService : IHostedService, IDisposable
    {
        private Task? _executeTask;
        private CancellationTokenSource? _stoppingCts;

        /// <summary>
        /// Gets the Task that executes the background operation.
        /// </summary>
        /// <remarks>
        /// Will return <see langword="null"/> if the background operation hasn't started.
        /// </remarks>
        public virtual Task? ExecuteTask => _executeTask;

        /// <summary>
        /// This method is called when the <see cref="IHostedService"/> starts. The implementation should return a task that represents
        /// the lifetime of the long running operation(s) being performed.
        /// </summary>
        /// <param name="stoppingToken">Triggered when <see cref="IHostedService.StopAsync(CancellationToken)"/> is called.</param>
        /// <returns>A <see cref="Task"/> that represents the long running operations.</returns>
        /// <remarks>See <see href="https://learn.microsoft.com/dotnet/core/extensions/workers">Worker Services in .NET</see> for implementation guidelines.</remarks>
        protected abstract Task ExecuteAsync(CancellationToken stoppingToken);

        /// <summary>
        /// Triggered when the application host is ready to start the service.
        /// </summary>
        /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous Start operation.</returns>
        public virtual Task StartAsync(CancellationToken cancellationToken)
        {
            // Create linked token to allow cancelling executing task from provided token
            _stoppingCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

            // Store the task we're executing
            _executeTask = ExecuteAsync(_stoppingCts.Token);

            // If the task is completed then return it, this will bubble cancellation and failure to the caller
            if (_executeTask.IsCompleted)
            {
                return _executeTask;
            }

            // Otherwise it's running
            return Task.CompletedTask;
        }

        /// <summary>
        /// Triggered when the application host is performing a graceful shutdown.
        /// </summary>
        /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous Stop operation.</returns>
        public virtual async Task StopAsync(CancellationToken cancellationToken)
        {
            // Stop called without start
            if (_executeTask == null)
            {
                return;
            }

            try
            {
                // Signal cancellation to the executing method
                _stoppingCts!.Cancel();
            }
            finally
            {
#if NET8_0_OR_GREATER
                await _executeTask.WaitAsync(cancellationToken).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
#else
                // Wait until the task completes or the stop token triggers
                var tcs = new TaskCompletionSource<object>();
                using CancellationTokenRegistration registration = cancellationToken.Register(s => ((TaskCompletionSource<object>)s!).SetCanceled(), tcs);
                // Do not await the _executeTask because cancelling it will throw an OperationCanceledException which we are explicitly ignoring
                await Task.WhenAny(_executeTask, tcs.Task).ConfigureAwait(false);
#endif
            }

        }

        /// <inheritdoc />
        public virtual void Dispose()
        {
            _stoppingCts?.Cancel();
        }
    }
}

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Extensions.Hosting
{
    /// <summary>
    /// Defines methods for objects that are managed by the host.
    /// 訳：ホストによって管理されるオブジェクトのためのメソッドを定義する
    /// </summary>
    public interface IHostedService
    {
        /// <summary>
        /// Triggered when the application host is ready to start the service.
        /// 訳：アプリケーションホストがサービスを開始する準備が整ったときに発動される
        /// </summary>
        /// <param name="cancellationToken">Indicates that the start process has been aborted. 訳：開始処理が中止されたことを表す</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous Start operation. 約：非同期の開始処理を表す</returns>
        Task StartAsync(CancellationToken cancellationToken);

        /// <summary>
        /// Triggered when the application host is performing a graceful shutdown. 訳：アプリケーションホストが正常にシャットダウン処理を実行しているときに呼ばれる
        /// </summary>
        /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful. 訳：シャットダウン処理がこれ以上正常に行われるべきでないことを表す</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous Stop operation. 訳：非同期の停止処理を表す</returns>
        Task StopAsync(CancellationToken cancellationToken);
    }
}

//
// 概要:
//     Provides a mechanism for releasing unmanaged resources.　訳：アンマネージリソースを解放する仕組みを提供する
public interface IDisposable
{
    //
    // 概要:
    //     Performs application-defined tasks associated with freeing, releasing, or resetting
    //     unmanaged resources. 訳：アンマネージリソースの解放・破棄・リセットに関連する、アプリケーション定義の処理を実行する
    void Dispose();
}

    while (!stoppingToken.IsCancellationRequested)
    {
        if (_logger.IsEnabled(LogLevel.Information))
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

            Console.WriteLine("Hello, World!");

        }
        await Task.Delay(1000, stoppingToken);
    }

	public string ProductCode { get; }
	public string Name { get; }
	public decimal Price { get; }
	public string? HaibanDate { get; }

	public Product(string productCode, string name, decimal price, string? haibanDate = null)
	{
		if (string.IsNullOrWhiteSpace(productCode)) throw new ArgumentException("製品CDは必須です");
		if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("名称は必須です");
		if (price < 0) throw new ArgumentException("製品価格は必須です");
		if (haibanDate != null)
		{
			if (!DateTime.TryParseExact(haibanDate, "yyyyMMdd", null, System.Globalization.DateTimeStyles.None, out _))
				throw new ArgumentException("廃番日が有効な日付ではない");
		}

		ProductCode = productCode;
		Name = name;
		Price = price;
		HaibanDate = haibanDate;
	}

public interface IProductRepository
{
	// 今回はFindのみ
	Product? Find(string productCode);
}

// sealedとする理由：「このクラスは継承しないでほしい」旨の意思表示
public sealed class InMemoryProductRepository : IProductRepository
{
	private readonly Dictionary<string, Product> _store = new();

	public void Add(Product product)
	{
		_store[product.ProductCode] = product;
	}

	public Product? Find(string productCode)
	{
		return _store.TryGetValue(productCode, out var product) ? product : null;
	}
}

public class ProductService
{
	private readonly IProductRepository _repository;

	public ProductService(IProductRepository repository)
	{
		_repository = repository;
	}

	public string? GetProductName(string productCode)
	{
		return _repository.Find(productCode)?.Name;
	}
}

	[TestMethod]
	public void GetProductName_ValidCode_ReturnsName()
	{
		var repo = new InMemoryProductRepository();
		repo.Add(new Product("001", "商品A", 100));
		// ProductServiceオブジェクトが必要とする依存先を（repo）を外部から注入する
		var service = new ProductService(repo);

		var result = service.GetProductName("001");

		Assert.AreEqual("商品A", result);
	}

	[TestMethod]
	public void GetProductName_InvalidCode_ReturnsNull()
	{
		var repo = new InMemoryProductRepository();
		// ProductServiceオブジェクトが必要とする依存先を（repo）を外部から注入する
		var service = new ProductService(repo);

		var result = service.GetProductName("999");

		Assert.IsNull(result);
	}

public class SpyProductRepository : IProductRepository
{
	public int CallCount { get; private set; } = 0;

	public Product? Find(string productCode)
	{
		// メソッドが呼ばれた回数をカウント
		CallCount++;
		return new Product(productCode, "Spy商品", 123);
	}
}

	public Product? Find(string productCode)
	{
		// メソッドが呼ばれたときにCalledMethodへ追加
		CalledMethod += @$" SpyProductRepository.Find( productCode:\"{productCode}\" )";
		return new Product(productCode, "Spy商品", 123);
	}

[TestMethod]
public void GetProductName_RepositoryCalledOnce()
{
	var repo = new SpyProductRepository();
		// ProductServiceオブジェクトが必要とする依存先を（repo）を外部から注入する
	var service = new ProductService(repo);

	service.GetProductName("001");
	Assert.AreEqual(1, repo.CallCount);
}

public interface IProductRepository
{
    // Find は習慣的に決まっている名前
    Product? Find(string productCode);
}

// テスト用の取得・更新用クラスはsealedにすることが一般的
public sealed class InMemoryProductRepository : IProductRepository
{
    // テスト用 Product 向けリポジトリクラス
    Product? Find(string productCode)
    {
        // テスト用の値を返すロジック
        return new Product
        ・
        ・
        ・
    }
}

var mock = new Mock<IProductRepository>();
mock.Setup(x => x.Find("001")).Returns(new Product("001", "商品A", 100));

public class Product
{
    /// <summary>
    /// 製品CD
    /// </summary>
    public string ProductCode { get; }

    /// <summary>
    /// 製品名称
    /// </summary>
    public string Name { get; }

    /// <summary>
    /// 価格
    /// </summary>
    public decimal Price { get; }

    /// <summary>
    /// 廃番日付
    /// </summary>
    public string? HaibanDate { get; }

    public Product(string productCode, string name, decimal price)
    {
        if (string.IsNullOrWhiteSpace(productCode)) throw new ArgumentException("製品CDは必須です");
        if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("名称は必須です");
        if (price < 0) throw new ArgumentException("製品価格は必須です");
        if (haibanDate != null)
        {
            if (!DateTime.TryParseExact(haibanDate, "yyyyMMdd", null, System.Globalization.DateTimeStyles.None, out _))
                throw new ArgumentException("廃番日付が有効な日付ではない");
        }

        ProductCode = productCode;
        Name = name;
        Price = price;
        HaibanDate = haibanDate;
    }
}

public class Zaiko
{
    public string ProductCode { get; }
    public int ZaikoSu { get; private set; }

    public Zaiko(string productCode, int zaikoSu)
    {
        if (string.IsNullOrWhiteSpace(productCode)) throw new ArgumentException("製品CDは必須");
        if (zaikoSu < 0) throw new ArgumentException("在庫数はゼロ以上のみ有効");

        ProductCode = productCode;
        ZaikoSu = zaikoSu;
    }

    public void AddZaikoSu(int amount)
    {
        if (amount <= 0) throw new ArgumentException("追加在庫数はゼロ以上のみ有効");
        ZaikoSu += amount;
    }
}

[TestClass]
public class ProductTests
{
    [TestMethod]
    [Priority(0001)] // テストの優先度
    public void コンストラクタ01()
    {
        var target = new Product("001", "商品A", 100, "20250101");
        Assert.AreEqual("001", target.ProductCode);
        Assert.AreEqual("商品A", target.Name);
        Assert.AreEqual(100, target.Price);
        Assert.AreEqual(target.HaibanDate, "20250101");
    }
}

[TestClass]
public class ZaikoTests
{
    [TestMethod]
    [Priority(0001)]
    public void コンストラクタ()
    {
        var target = new Zaiko("001", 10);
        Assert.AreEqual("001", target.ProductCode);  
        Assert.AreEqual(10, target.ZaikoSu);
    }
}

[TestClass]
public class ProductTests
{
    [TestMethod]
    [Priority(0001)]    // テストの優先度を設定
    public void コンストラクタ()
    {
        var target = new Product("001", "商品A", 100, "20250101");
        Assert.AreEqual("001", target.ProductCode);
        Assert.AreEqual("商品A", target.Name);
        Assert.AreEqual(100, target.Price);
        Assert.AreEqual(target.HaibanDate, "20250101");
    }

    [TestMethod]
    [Priority(0002)]
    public void コンストラクタ_Exception_ProductCode()
    {
        Assert.ThrowsException<ArgumentException>(() => new Product("", "商品A", 100));
    }
    /* 
     * 以下の通りにも記述可能です。
     * ただ、カバレッジツールの制約上最後の } が未テスト行として認識されます。
     * 
    [Priority(0002)]
    [ExpectedException(typeof(ArgumentException))]  // 例外が発生することを確認するテストコード
    public void コンストラクタ_Exception_ProductCode()
    {
        var target = new Product("", "商品A", 100);
    }
     */

    [TestMethod]
    [Priority(0003)]
    public void コンストラクタ_Exception_Name()
    {
        Assert.ThrowsException<ArgumentException>(() => new Product("001", "", 100));
    }

    [TestMethod]
    [Priority(0004)]
    public void コンストラクタ_Exception_Price()
    {
        Assert.ThrowsException<ArgumentException>(() => new Product("001", "商品A", -1M));
    }

    [TestMethod]
    [Priority(0005)]
    public void コンストラクタ_Exception_HaibanDate()
    {
        Assert.ThrowsException<ArgumentException>(() => new Product("001", "商品A", 100, "100"));
    }
}

public class ZaikoTests
{
    [TestMethod]
    [Priority(0001)]
    public void コンストラクタ()
    {
        var target = new Zaiko("001", 10);
        Assert.AreEqual("001", target.ProductCode);  
        Assert.AreEqual(10, target.ZaikoSu);
    }

    [TestMethod]
    [Priority(0002)]
    public void コンストラクタ_Exception_ProductCode()
    {
        Assert.ThrowsException<ArgumentException>(() => new Zaiko("", 10));
    }

    [TestMethod]
    [Priority(0003)]
    public void コンストラクタ_Exception_ZaikoSu()
    {
        Assert.ThrowsException<ArgumentException>(() => new Zaiko("001", -1));
    }

    [TestMethod]
    [Priority(0101)]
    public void AddZaikoSu_Exception()
    {
        var target = new Zaiko("001", 10);
        Assert.ThrowsException<ArgumentException>(() => target.AddZaikoSu(-1));
    }

    [TestMethod]
    [Priority(0102)]
    public void AddZaikoSu()
    {
        var target = new Zaiko("001", 10);
        target.AddZaikoSu(1);
        Assert.AreEqual(11, target.ZaikoSu);
    }
}