by Joche Ojeda | Jan 13, 2023 | netcore
Running an application as a service in macOS can be accomplished using a tool called launchd. launchd is a system-wide daemon manager that is built into macOS. It can be used to run applications automatically at startup, or on a schedule. In this article, we’ll show you how to run an application as a service using launchd, and explain the difference between LaunchDaemons and LaunchAgents.
Step 1: Create a launchd plist file The first step in running an application as a service using launchd is to create a property list file called a “launchd plist”. This file defines the service and its settings, including the name, program to run, and any environment variables or other settings. The plist file is an XML file and should have the extension .plist. An example of a plist file is the following:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.example.myservice</string>
<key>ProgramArguments</key>
<array>
<string>/path/to/your/program</string>
</array>
<key>KeepAlive</key>
<true/>
</dict>
</plist>
Step 2: Copy the plist file to the appropriate directory Once the plist file is created, you will need to copy it to the appropriate directory. There are two main directories for launchd plist files: /Library/LaunchDaemons/ and /Library/LaunchAgents/.
The difference between LaunchDaemons and LaunchAgents is that LaunchDaemons are used to run background services that do not require a user to be logged in, while LaunchAgents are used to run applications that are associated with a specific user account.
For example, if you want to run a service that starts automatically at boot time and runs in the background, you would copy the plist file to /Library/LaunchDaemons/. If you want to run an application that starts automatically when a user logs in, you would copy the plist file to /Library/LaunchAgents/.
Step 3: Load the service Once the plist file is in the appropriate directory, use the launchctl command to load the service. For example:
sudo launchctl load /Library/LaunchDaemons/com.example.myservice.plist
Step 4: Verify that the service is running You can use the launchctl command to check the status of the service:
launchctl list
This will show all the services that are currently running, and their status.
In summary, launchd is a powerful tool built into macOS that allows you to run applications as services. To use launchd, you need to create a plist file that defines the service and its settings, then copy it to the appropriate directory, and load it using the launchctl command. The difference between LaunchDaemons and LaunchAgents is that the former are used to run background services that do not require a user to be logged in, while the latter are used to run applications that are associated with a specific user account.
by Joche Ojeda | Jan 9, 2023 | EfCore
In Entity Framework 7, lazy loading is a technique used to delay the loading of related entities until they are actually needed. This can help to improve the performance of an application by reducing the amount of data that is retrieved from the database upfront.
To implement lazy loading in EF7, the “virtual” modifier is used on the navigation properties of an entity class. Navigation properties are used to represent relationships between entities, such as one-to-many or many-to-many.
For example, consider the following code snippet for a “Course” entity class and a “Student” entity class in EF7, with a one-to-many relationship between them:
public class Course
{
public int CourseId { get; set; }
public string CourseName { get; set; }
public virtual ICollection<Student> Students { get; set; }
}
public class Student
{
public int StudentId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public int CourseId { get; set; }
public virtual Course Course { get; set; }
}
In this example, the “Students” navigation property in the “Course” class and the “Course” navigation property in the “Student” class are both marked as “virtual”. This allows EF7 to override these properties with a proxy at runtime, enabling lazy loading for the related entities.
To use lazy loading in an EF7 application, the “DbContext.LazyLoadingEnabled” property must be set to “true”. When lazy loading is enabled, related entities will not be loaded from the database until they are actually accessed.
For example, the following code demonstrates how lazy loading can be used to retrieve a list of courses and their students:
using (var context = new SchoolContext())
{
context.LazyLoadingEnabled = true;
var courses = context.Courses.ToList();
foreach (var course in courses)
{
Console.WriteLine("Course: " + course.CourseName);
foreach (var student in course.Students)
{
Console.WriteLine("Student: " + student.FirstName + " " + student.LastName);
}
}
}
In this code, the list of courses is retrieved from the database and stored in the “courses” variable. The students for each course are not retrieved until they are accessed in the inner loop. This allows the application to retrieve only the data that is needed, improving performance and reducing the amount of data transferred from the database.
Lazy loading can be a useful tool for optimizing the performance of an EF7 application, but it is important to consider the trade-offs and use it appropriately. Lazy loading can increase the number of database queries and the overall complexity of an application, and it may not always be the most efficient approach.
by Joche Ojeda | Jan 2, 2023 | C#
Integration tests are a crucial part of any software development process, as they help ensure that different parts of a system are working together correctly. When writing integration tests, it is important to follow best practices in order to ensure that your tests are effective and maintainable. Here are a few good practices for integration testing using NUnit:
- Use test fixtures: NUnit provides a concept called “test fixtures,” which allow you to set up and tear down common resources that are needed by multiple test cases. This can help reduce duplication and make your tests more maintainable.
[TestFixture]
public class DatabaseTests
{
private Database _database;
[SetUp]
public void SetUp()
{
_database = new Database();
}
[TearDown]
public void TearDown()
{
_database.Dispose();
}
[Test]
public void Test1()
{
// test code goes here
}
[Test]
public void Test2()
{
// test code goes here
}
}
- Use setup and teardown methods: In addition to test fixtures, NUnit also provides setup and teardown methods that can be used to perform common tasks before and after each test case. This can be helpful for setting up test data or cleaning up after a test.
[TestFixture]
public class DatabaseTests
{
private Database _database;
[SetUp]
public void SetUp()
{
_database = new Database();
}
[TearDown]
public void TearDown()
{
_database.Dispose();
}
[SetUp]
public void TestSetup()
{
// setup code goes here
}
[TearDown]
public void TestTeardown()
{
// teardown code goes here
}
[Test]
public void Test1()
{
// test code goes here
}
[Test]
public void Test2()
{
// test code goes here
}
}
- Use test cases: NUnit allows you to specify multiple test cases for a single test method using the
TestCase attribute. This can help reduce duplication and make it easier to test different scenarios.
[TestFixture]
public class CalculatorTests
{
[TestCase(1, 2, 3)]
[TestCase(10, 20, 30)]
[TestCase(-1, -2, -3)]
public void TestAdd(int x, int y, int expected)
{
Calculator calculator = new Calculator();
int result = calculator.Add(x, y);
Assert.AreEqual(expected, result);
}
}
- Use the
Assert class: NUnit provides a variety of assertions that can be used to verify the behavior of your code. It is important to use these assertions rather than manually checking for expected results, as they provide better error messages and make it easier to debug test failures.
[TestFixture]
public class CalculatorTests
{
[Test]
public void TestAdd()
{
Calculator calculator = new Calculator();
int result = calculator.Add(1, 2);
Assert.AreEqual(3, result);
}
[Test]
public void TestSubtract()
{
Calculator calculator = new Calculator();
int result = calculator.Subtract(10, 5);
Assert.AreEqual(5, result);
}
}
- Use test categories: NUnit allows you to categorize your tests using the
Category attribute. This can be helpful for organizing your tests and selectively running only certain categories of tests.
[TestFixture]
public class DatabaseTests
{
[Test]
[Category("Database")]
public void Test1()
{
// test code goes here
}
[Test]
[Category("Database")]
public void Test2()
{
// test code goes here
}
[Test]
[Category("API")]
public void Test3()
{
// test code goes here
}
}
By following these best practices, you can write integration tests that are effective, maintainable, and easy to understand. This will help you ensure that your code is working correctly and reduce the risk of regressions as you continue to develop and evolve your system.
by Joche Ojeda | Dec 31, 2022 | C#
ARM (Advanced RISC Machine) is a popular architecture for mobile devices and other low-power devices. Microsoft has supported ARM architectures in the .NET framework for many years, and this support has continued with the release of .NET 6 and .NET 7.
In .NET 6 and 7, support for ARM architectures has been improved and expanded in several ways. One of the key changes is the introduction of ARM64 JIT (Just-In-Time) compilation, which allows .NET applications to take advantage of the performance improvements offered by the ARM64 architecture. This means that .NET applications can now be compiled and run natively on ARM64 devices, providing better performance and a more seamless experience for users.
Another important change in .NET 6 and 7 is the support for ARM32 and ARM64 for ASP.NET and ASP.NET Core. This means that developers can now build and deploy web applications on ARM devices, making it easier to create cross-platform applications that can run on a wide range of devices.
In addition to these changes, .NET 6 and 7 also include support for ARM64 in the .NET Native toolchain, which allows developers to build native applications for ARM devices using C# and .NET. This makes it easier to create high-performance, native applications for ARM devices without having to write code in a different language.
In conclusion, the support for ARM architectures in .NET 6 and 7 is an important development for developers who are looking to create and deploy applications on devices such as Apple’s M1 and M2. With this support, developers can take advantage of the performance and capabilities of the ARM architecture to create powerful and efficient applications that can run on a variety of devices. This will make it easier for developers to create and deploy applications on a wide range of devices, including mobile devices and other low-power devices. Overall, the support for ARM architectures in .NET 6 and 7 is a major improvement that will help developers create and deploy high-quality applications on a variety of devices.
by Joche Ojeda | Dec 30, 2022 | C#
In this article, we will be discussing why it is sometimes useful to wrap your synchronous implementation in an asynchronous implementation.
Introduction
Async programming is an important paradigm in modern software development, allowing you to perform long-running tasks without blocking the calling thread. Async programming is particularly useful in scenarios where the operation may take a long time to complete, or when the operation is interacting with a slow resource, such as a network or a database.
One common scenario where you may need to wrap your synchronous implementation in an asynchronous implementation is when you are working with an API or a library that does not provide async versions of its methods. In these cases, you can use the Task.Run method to wrap the synchronous methods in a task, allowing you to use the await keyword to asynchronously wait for the operation to complete.
Example: Wrapping a Synchronous Data Processor
To illustrate this concept, let’s consider the following synchronous IDataProcessor interface:
public interface IDataProcessor
{
void ProcessData(IEnumerable<IData> data);
}
This interface has a single method, ProcessData, which takes an IEnumerable of IData objects as input and processes the data.
Now let’s say that you want to use this IDataProcessor interface in an async context, but the interface does not provide an async version of the ProcessData method. To use this interface asynchronously, you can create an async wrapper class that wraps the synchronous implementation in an async implementation.
Here is an example of how you can wrap the synchronous IDataProcessor implementation in an asynchronous implementation:
public class AsyncDataProcessor : IDataProcessor
{
private readonly IDataProcessor _dataProcessor;
public AsyncDataProcessor(IDataProcessor dataProcessor)
{
_dataProcessor = dataProcessor;
}
public Task ProcessDataAsync(IEnumerable<IData> data)
{
return Task.Run(() => _dataProcessor.ProcessData(data));
}
}
This implementation has a single method, ProcessDataAsync, which takes an IEnumerable of IData objects as input and asynchronously processes the data. The implementation uses the Task.Run method to wrap the synchronous ProcessData method in a task, allowing it to be called asynchronously using the await keyword.
To use this implementation, you can simply create an instance of AsyncDataProcessor and call the ProcessDataAsync method, passing in the list of data as an argument. For example:
var dataProcessor = new AsyncDataProcessor(new DataProcessor());
await dataProcessor.ProcessDataAsync(data);
This code creates an instance of the AsyncDataProcessor class and calls the ProcessDataAsync method, passing in the data object as an argument. The await keyword is used to asynchronously wait for the data processing to complete.
Conclusion
In this article, we discussed why it is sometimes useful to wrap your synchronous implementation in an asynchronous implementation. We used the Task.Run method to wrap a synchronous IDataProcessor implementation in an async implementation, allowing us to use the await keyword
