#xUnit .NET

[fullstackverse]

Learning ASP.NET Core Online: Tips for Fast-Tracking Your Skills

In the rapidly evolving tech world, staying ahead means continuously upgrading your skill set. Among the most in-demand frameworks today is ASP.NET Core, and mastering it can open doors to exciting development careers. For those ready to dive in, enrolling in an asp net core online course or committing to a structured ASP.NET Core training online can be your golden ticket.

Whether you're a complete beginner or transitioning from another framework, this article is your comprehensive guide to learning ASP.NET Core online efficiently. From structured strategies to tips that actually work, you’ll find everything you need here.

Why ASP.NET Core is Worth Learning

ASP.NET Core is a modern, high-performance framework developed by Microsoft for building cloud-based, internet-connected applications. It's open-source, cross-platform, and incredibly fast. With more companies adopting microservices architecture and container-based deployment, ASP.NET Core is increasingly at the forefront.

Power of ASP.NET Core in the Job Market

Many organizations are migrating their legacy .NET applications to ASP.NET Core to take advantage of its speed, scalability, and flexibility. Knowing this framework gives you a competitive edge in roles like backend developer, full-stack developer, and DevOps engineer.

Best Practices to Start Learning ASP.NET Core Online

1. Set Clear Goals

Before jumping into any online course, define what you want to achieve. Are you aiming for certification, job readiness, or just knowledge enhancement? Having a goal will help you choose the right course and maintain your motivation.

2. Choose Structured Learning Paths

A random collection of YouTube tutorials may not provide a comprehensive understanding. Instead, opt for a complete course structure that includes fundamentals, advanced topics, real-world projects, and assessments. Platforms offering certifications can also boost your resume.

3. Use Hands-On Projects to Practice

Theory alone won't help you master ASP.NET Core. Apply what you learn by building projects such as:

A blog or CMS

An eCommerce store

A RESTful API with Entity Framework

Microservices-based applications

These not only reinforce concepts but also enrich your portfolio.

Top Resources to Fast-Track Your Learning

1. Microsoft Learn

Microsoft's own documentation and learning paths are incredibly thorough. They are up-to-date, official, and cover everything from beginner to advanced topics.

2. Community Blogs and GitHub Repositories

Explore ASP.NET Core projects on GitHub. These repositories often include documentation, unit tests, and CI/CD integrations—valuable skills to learn alongside coding.

3. Enroll in a Quality ASP.NET Core Online Course

Platforms like ScholarHat offer courses tailored to fast-tracking your learning, complete with mentorship, projects, and quizzes. Their ASP.NET Core training online is structured to help learners become job-ready.

Common Mistakes to Avoid

1. Skipping Fundamentals

ASP.NET Core builds upon many essential concepts such as MVC architecture, dependency injection, middleware, and routing. Missing these can hinder your growth.

2. Not Writing Enough Code

Many learners spend too much time watching lectures without coding. Always supplement videos with active development time.

3. Ignoring Testing and Debugging

Good developers know how to test and debug effectively. Make use of xUnit, Moq, and built-in debugging tools in Visual Studio or Visual Studio Code.

Learning Path for Different Levels

Beginner Level

Learn C# fundamentals

Understand .NET basics

Explore MVC pattern

Build a simple CRUD application

Intermediate Level

Dependency injection

Middleware pipeline

Authentication & Authorization

Unit Testing & Debugging

Advanced Level

API development

Integrating with third-party APIs

CI/CD with Azure DevOps

Containerization with Docker

How to Stay Consistent and Motivated

1. Join Online Communities

Whether it’s Stack Overflow, Reddit, or Discord channels, connecting with fellow learners and professionals keeps you motivated.

2. Take Notes and Revisit Them

Create a personal knowledge base. This will help you during interviews and when revisiting concepts.

3. Track Your Progress

Platforms like ScholarHat provide progress tracking features in their courses. Seeing how far you've come keeps you moving forward.

Career Opportunities After Mastery

Learning ASP.NET Core opens doors to multiple career paths:

Backend Developer

Full Stack Developer

.NET Engineer

Cloud Application Developer

DevOps Engineer

In the middle of your learning journey, make sure to reflect on your progress and adjust your goals accordingly. It's crucial to keep your learning dynamic and project-driven.

Real-World Projects You Can Build

1. Expense Tracker Application

Use CRUD operations, authentication, and charting.

2. Hospital Management System

Implement REST APIs, database integration, and admin panels.

3. Microservice-Based eCommerce Platform

Integrate different services like cart, user, payment, and product services.

4. Portfolio Website

Utilize MVC, Entity Framework, and third-party APIs.

5. Social Media Clone

Create a scalable application with user posts, comments, likes, and notifications.

Conclusion: Fast-Track Your Growth Today

By strategically following the tips outlined above, you can accelerate your learning and build real-world competencies. Learning ASP.NET Core online: tips for fast-tracking your skills doesn’t just equip you with knowledge; it prepares you for success in the development world.

Start your journey today with a structured asp net core online course or a guided ASP.NET Core training online.

Frequently Asked Questions (FAQs)

What is the difference between .NET and ASP.NET Core?

.NET is the overall development platform, while ASP.NET Core is a web framework under .NET used specifically for building web applications.

Can I learn ASP.NET Core without prior coding knowledge?

It's recommended to know C# before diving into ASP.NET Core. It makes understanding the framework much easier.

How long does it take to master ASP.NET Core?

Depending on your pace, dedication, and previous experience, it may take 3 to 6 months.

Is ASP.NET Core open-source?

Yes, ASP.NET Core is completely open-source and maintained by Microsoft and the community.

What are the prerequisites for ASP.NET Core?

A solid understanding of C#, object-oriented programming, and web development basics is essential.

Which IDE is best for ASP.NET Core development?

Visual Studio and Visual Studio Code are both widely used and fully support ASP.NET Core.

Can ASP.NET Core be used for mobile app development?

Indirectly, yes—via APIs that support mobile frontends or with tools like Xamarin.

How do I deploy an ASP.NET Core application?

You can deploy it using Azure, Docker containers, or traditional hosting environments.

Is ASP.NET Core used in large-scale enterprise applications?

Yes, many large enterprises have adopted ASP.NET Core for its performance and scalability.

What certifications are available for ASP.NET Core?

Microsoft and other training platforms offer official certifications that validate your skills in ASP.NET Core.

[hiringjournal]

Interview Questions to Ask When Hiring a .NET Developer

The success of your enterprise or web apps can be significantly impacted by your choice of .NET developer. Making the correct decision during interviews is crucial because .NET is a powerful framework that is utilized in a variety of industries, including finance and e-commerce. Dot Net engineers that are not only familiar with the framework but also have the ability to precisely and clearly apply it to real-world business problems are sought after by many software businesses.

These essential questions will assist you in evaluating candidates' technical proficiency, coding style, and compatibility with your development team as you get ready to interview them for your upcoming project.

Assessing Technical Skills, Experience, and Real-World Problem Solving

What experience do you have with the .NET ecosystem?

To find out how well the candidate understands .NET Core, ASP.NET MVC, Web API, and associated tools, start with a general question. Seek answers that discuss actual projects and real-world applications rather than only theory.

Follow-up: What version of .NET are you using right now, and how do you manage updates in real-world settings?

Experience with more recent versions, such as .NET 6 or .NET 8, can result in fewer compatibility problems and improved performance when hiring Dot Net developers.

How do you manage dependency injection in .NET applications?

One essential component of the scalable .NET design is dependency injection. An excellent applicant will discuss built-in frameworks, how they register services, and how they enhance modularity and testability.

Can you explain the difference between synchronous and asynchronous programming in .NET?

Performance is enhanced by asynchronous programming, particularly in microservices and backend APIs. Seek a concise description and examples that make use of Task, ConfigureAwait, or async/await.

Advice: When hiring backend developers, candidates who are aware of async patterns are more likely to create apps that are more efficient.

What tools do you use for debugging and performance monitoring?

Skilled developers know how to optimize code in addition to writing it. Check for references to Postman, Application Insights, Visual Studio tools, or profiling tools such as dotTrace.

This demonstrates the developer's capacity to manage problems with live production and optimize performance.

How do you write unit and integration tests for your .NET applications?

Enterprise apps require testing. A trustworthy developer should be knowledgeable about test coverage, mocking frameworks, and tools like xUnit, NUnit, or MSTest.

Hiring engineers with strong testing practices helps tech organizations avoid expensive errors later on when delivering goods on short notice.

Describe a time you optimized a poorly performing .NET application.

This practical question evaluates communication and problem-solving abilities. Seek solutions that involve database query optimization, code modification, or profiling.

Are you familiar with cloud deployment for .NET apps?

Now that a lot of apps are hosted on AWS or Azure, find out how they handle cloud environments. Seek expertise in CI/CD pipelines, containers, or Azure App Services.

This is particularly crucial if you want to work with Dot Net developers to create scalable, long-term solutions.

Final Thoughts

You may learn more about a developer's thought process, problem-solving techniques, and ability to operate under pressure via a well-structured interview. These questions provide a useful method to confidently assess applicants if you intend to hire Dot Net developers for intricate or high-volume projects.

The ideal .NET hire for expanding tech organizations does more than just write code; they create the framework around which your products are built.

[keploy]

Python Unit Testing: A Complete Guide

When you write code, how do you know it actually works? You could run the program and click around manually—but that quickly becomes tedious, unreliable, and error-prone, especially as your codebase grows. That’s where unit testing comes in.

Unit testing lets you verify that individual pieces of your code—like functions or methods—behave exactly the way you expect. It's not just about finding bugs (though it helps with that); it's about building confidence in your code, catching issues early, and enabling safe changes in the future. Whether you're working solo or on a large team, testing is one of the smartest habits you can adopt for long-term success in software development

What is Unit Testing in Python?

Unit testing is the practice of validating the smallest components of your software—such as individual functions, methods, or classes—in complete isolation. The primary goal is to ensure that each "unit" of code performs exactly as intended under various conditions. It acts as an early safety net, catching potential bugs before they make their way into larger, integrated systems.

In Python, unit testing is a crucial pillar of Test-Driven Development (TDD) and robust software engineering practices. By systematically verifying each component, developers can build more reliable, maintainable, and scalable applications.

Why Unit Testing Matters:

Catches errors early: Bugs are easier and cheaper to fix when detected at the unit level rather than after full integration.

Facilitates better design: Writing testable code often leads to modular, loosely-coupled architectures—hallmarks of good software design.

Acts as living documentation: Well-written unit tests serve as executable examples, helping new developers quickly understand how individual pieces of code are intended to work.

Enables safe refactoring: With unit tests in place, developers can confidently refactor or enhance code without fear of breaking existing functionality.

Improves overall code quality: Regular testing encourages developers to think critically about edge cases and input validation.

Common Characteristics of a Good Unit Test:

Focuses on one behavior only: A unit test should validate just a single piece of functionality to maintain clarity and reliability.

Runs fast: Tests should execute quickly to allow frequent and seamless testing during development.

Independent of external systems: Unit tests should not rely on databases, file systems, or external APIs. If necessary, dependencies should be mocked or stubbed.

Deterministic and repeatable: A good unit test produces the same output for the same input every time, ensuring consistent results across different environments.

Readable and maintainable: Other developers should be able to understand a test's purpose quickly without needing extensive comments or documentation.

🎯 Pro Tip: Always treat your unit tests as first-class citizens of your codebase. They deserve the same level of care, readability, and maintainability as production code.

What is the Python unittest Module?

Python’s built-in unittest module follows the xUnit style, which is widely recognized in the software industry. It’s part of the Python Standard Library, meaning you don't need to install anything extra.

Powerful features of unittest:

Grouping tests into classes and modules.

Built-in assertions for checking values and exceptions.

Automatic test discovery to find and run tests easily.

Easy setup and cleanup with setUp() and tearDown() methods.

Example usage:import unittest def add(a, b): return a + b class TestAddFunction(unittest.TestCase): def test_add_positive_numbers(self): self.assertEqual(add(2, 3), 5) def test_add_negative_numbers(self): self.assertEqual(add(-1, -2), -3) if __name__ == '__main__': unittest.main()

What is Keploy? How Does Keploy Help You with Testing?

Keploy is an open-source testing platform that helps developers generate test cases and mocks automatically—based on real API calls and application behavior. Instead of writing every unit or integration test manually, Keploy captures real interactions with your application and turns them into structured test suites you can run repeatedly.

Keploy Offers Three Testing Solutions:

🧪 Unit Testing: Keploy has recently released a Unit Testing Agent that generates stable, useful unit tests directly in your GitHub PRs — covering exactly what matters. How cool is this? Testing directly in PRs – so developers won’t need to write test cases for their new features. Keploy writes them for you! No noisy stuff – just clean, focused tests targeting the code changes.

🔌 Integration Testing: Records real API calls, DB queries, and service interactions to generate full integration tests. Best for ensuring multiple components work together correctly.

🌐 API Testing: Captures and replays HTTP(S) requests to test external APIs and endpoints. Helps ensure response consistency and backward compatibility.

Think of Keploy as your intelligent testing assistant that watches your app in action and learns how to test it.

Benefits of Using Keploy

Saves Time: No need to manually write every test—Keploy does the heavy lifting for you.

Keeps Tests Realistic: Since tests are generated from real user interactions, they closely reflect how your app is actually used.

Boosts Test Coverage Effortlessly: Even if you’re not writing tests yourself, Keploy ensures your application gets tested thoroughly.

Helps Catch Regressions Early: You can rerun recorded test cases after code changes to make sure nothing breaks.

Easy Integration: Keploy integrates smoothly into your CI/CD pipelines, making it easy to automate testing at every stage.

How to Define Unit Test Cases for Python Functions?

Writing unit test cases for your Python functions is a crucial step in ensuring your code works as expected—not just today, but whenever changes are made in the future. Unit tests help you catch bugs early, prevent regressions, and give you the confidence to refactor and improve your code.

Here’s how you can define unit test cases effectively:

1. Use the unittest Module

Python comes with a built-in testing framework called unittest, which makes it easy to create and run tests. To get started, import the module and create a test class that inherits from unittest.TestCase.import unittest from my_module import add_numbers class TestMathFunctions(unittest.TestCase): def test_add_positive_numbers(self): self.assertEqual(add_numbers(2, 3), 5) def test_add_negative_numbers(self): self.assertEqual(add_numbers(-2, -3), -5) def test_add_mixed_numbers(self): self.assertEqual(add_numbers(-1, 4), 3) if __name__ == '__main__': unittest.main()

2. Structure Your Test Cases Clearly

Each test should focus on one specific behavior or input. Use meaningful names for your test methods to describe what they’re verifying. This makes your tests easy to read and understand.

3. Test Edge Cases and Exceptions

Don’t just test the “happy path.” Think about edge cases, invalid inputs, and how your function handles errors.def test_add_none_input(self): with self.assertRaises(TypeError): add_numbers(None, 2)

4. Keep Tests Independent

Tests should be self-contained. Avoid shared state between tests to prevent one test's outcome from affecting another’s.

5. Run Tests Frequently

Make it a habit to run your tests during development. Tools like pytest or automation via CI/CD pipelines can help streamline this process.

Assert Methods for Unit Testing in Python

When writing unit tests in Python using the unittest framework, assert methods are the core tools you use to check whether your code is producing the expected results. These methods compare actual output to the expected output, and if the comparison fails, the test fails.

Here are some commonly used assert methods you should know:

1. assertEqual(a, b)

Checks that a == b. This is the most commonly used method for comparing values.self.assertEqual(add_numbers(2, 3), 5)

2. assertNotEqual(a, b)

Checks that a != b.self.assertNotEqual(add_numbers(2, 2), 5)

3. assertTrue(x) / assertFalse(x)

Checks that a condition is True or False, respectively.self.assertTrue(is_valid_email("test@example.com")) self.assertFalse(is_valid_email("invalid-email"))

4. assertIs(a, b) / assertIsNot(a, b)

Checks that a is b (i.e., they are the same object) or not.self.assertIs(config, default_config)

5. assertIsNone(x) / assertIsNotNone(x)

Checks whether a variable is None or not.self.assertIsNone(get_user_by_id(999))

6. assertIn(a, b) / assertNotIn(a, b)

Checks that an element a is in container b (like a list or string), or not.self.assertIn("error", response.message)

7. assertRaises(Exception, callable, *args)

Checks that a specific exception is raised when a function is called with certain arguments.with self.assertRaises(ValueError): divide(10, 0)

Best Practices for Python Unit Testing

Writing unit tests is about more than just making sure your code works—it's about making sure your code continues to work as your project evolves. Following best practices helps keep your tests clean, reliable, and easy to maintain.

Here are some proven best practices for unit testing in Python:

1. Keep Tests Small and Focused

Each unit test should test one thing and one thing only. Don’t overload a single test case with multiple checks. If something goes wrong, you want to know exactly what failed and why.

2. Use Descriptive Test Names

Give your test functions clear, descriptive names that explain what they’re checking. This makes it easier to understand failures at a glance.def test_login_fails_with_invalid_password(self): ...

3. Test Edge Cases

Don’t just test the expected or "happy path." Think about how your code should behave with unexpected input, empty values, or large data sets.

4. Isolate Tests

Avoid dependencies between test cases. Each test should be able to run independently of the others. Use mocking when necessary to isolate external systems or APIs.

5. Use Setup and Teardown Methods Wisely

Use setUp() and tearDown() methods in your test classes to prepare test data or clean up resources, keeping your individual test methods clean.def setUp(self): self.user = create_test_user() def tearDown(self): delete_test_user(self.user)

6. Avoid Hardcoding Values

Hardcoding can make your tests brittle. Use variables or constants for test data to make it easier to update and reuse.

7. Run Tests Frequently

Make testing a regular part of your development workflow. Run tests before commits or integrate them into your CI/CD pipeline to catch issues early.

8. Keep Tests Fast

Unit tests should run quickly. If a test is slow due to external dependencies (like database calls or network requests), consider mocking those parts.

9. Don’t Ignore Failing Tests

Fix failing tests as soon as they break. Ignoring them defeats the purpose of having tests in the first place.

10. Strive for High Coverage—but Not at the Cost of Quality

Aim for good test coverage, but don’t just chase numbers. A few meaningful tests are better than many shallow ones.

PyTest vs Unittest: Core Differences

When it comes to writing unit tests in Python, two popular choices are unittest and pytest. Both frameworks help you ensure your code behaves as expected, but they differ in style, features, and ease of use. Let’s break down the core differences to help you choose the right one for your project.

1. Ease of Use and Syntax

unittest is part of the Python standard library and follows a class-based, Java-style structure. You define test classes that inherit from unittest.TestCase, and use specific assert methods.

pytest allows you to write simple test functions without needing to wrap them in classes. Assertions use plain assert statements, making tests more concise and readable.

Example:

Using unittest:import unittest class TestMath(unittest.TestCase): def test_add(self): self.assertEqual(2 + 3, 5)

Using pytest:def test_add(): assert 2 + 3 == 5

2. Assertion Style

unittest requires using specific assert methods like assertEqual, assertTrue, etc.

pytest lets you use standard Python assert statements. It also provides better failure messages out of the box, making debugging easier.

3. Fixtures and Setup

unittest uses setUp() and tearDown() methods for preparing and cleaning up test environments.

pytest offers more flexible and powerful fixtures, which can be reused across multiple tests, support dependency injection, and have various scopes (function, class, module, etc.).

4. Plugins and Extensibility

pytest has a rich ecosystem of plugins and community tools, including support for test coverage, mocking, parallel execution, and more.

unittest is more limited in terms of built-in extensibility, though it can work with some third-party tools.

5. Test Discovery

pytest automatically discovers tests by simply matching file and function names (e.g., files starting with test_).

unittest requires a bit more setup or must be run using unittest command-line options to discover and run tests.

6. Learning Curve

unittest is familiar to those coming from other xUnit-style frameworks (like JUnit or NUnit).

pytest is generally considered easier and more Pythonic, especially for beginners or those who prefer a cleaner, less verbose approach.

Why Unit Testing Should Be Non-Negotiable

Unit testing isn't just a nice-to-have—it's a must-have for any serious development workflow. Whether you're building a simple script or a large-scale application, unit tests act as a safety net that helps you write better, more reliable code.

Here’s why unit testing should be a non-negotiable part of your development process:

1. Catches Bugs Early

The earlier you catch a bug, the cheaper and easier it is to fix. Unit tests let you verify that individual pieces of your code work exactly as intended—before you integrate them into a larger system. That means fewer surprises down the line.

2. Supports Confident Refactoring

Refactoring is essential to keep code clean and maintainable. But without tests, changing code becomes risky. Unit tests give you the confidence to refactor aggressively, knowing that your changes won’t break existing functionality.

3. Improves Code Quality

When you're writing tests, you're forced to think critically about your code's design, structure, and edge cases. This often leads to better, more modular code that's easier to understand and maintain.

4. Speeds Up Debugging

When a test fails, it tells you exactly what’s broken and where to look. That targeted feedback makes debugging much faster than trying to trace through a full application to find the issue.

5. Documents Expected Behavior

Unit tests serve as live documentation for your code. They show exactly how a function is supposed to behave under different conditions. New developers on your team can often learn more from a well-written test than from a comment or docstring.

6. Essential for Automation and CI/CD

In modern software development, continuous integration and deployment are standard. Automated testing is at the heart of these pipelines—and unit tests are the foundation. Without them, you risk shipping broken code.

7. Reduces Technical Debt

Skipping tests might feel like saving time in the short term, but it often leads to fragile, unmaintainable code. Unit tests help you build a stable foundation that supports growth rather than hindering it.

Conclusion

Unit testing is not just a checkbox for quality assurance—it's a mindset and a habit that enables you to build reliable, maintainable, and scalable software. Whether you're a solo developer or part of a large engineering team, taking the time to write and maintain good unit tests pays dividends throughout your project's life. From catching bugs early to enabling safe refactors and documenting expected behavior, unit testing is an investment in the long-term health of your codebase. And with tools like unittest, pytest, and platforms like Keploy, there's never been a better time to start testing smartly and efficiently.

FAQs

1. Do I need to write unit tests for every function? Not necessarily. Focus on functions that contain logic, decision-making, or complex behavior. Utility functions that are trivial may not need detailed unit tests unless they're critical.

2. What makes Keploy different from other testing tools? Keploy automatically records real API interactions and turns them into test cases and mocks—saving developers time and effort. It helps increase test coverage, catch regressions early, and integrates smoothly into CI/CD workflows.

3. Can I use both unittest and pytest in the same project? Yes, you can. However, it’s recommended to choose one as your primary testing framework to maintain consistency and reduce complexity.

4. How do I know if my unit tests are effective? Good unit tests are fast, isolated, and easy to read. They test both typical and edge-case behaviors, provide meaningful feedback when they fail, and give you confidence to make changes without fear of breaking things.

5.How often should I run my unit tests during development? Ideally, run your unit tests every time you make a change. Frequent testing helps you catch mistakes as soon as they happen, making bugs easier to fix. Tools like pytest or CI/CD pipelines can automate this process so you don't have to think about it.

🔗 Recommended Blogs on Unit Testing

Unit Testing vs Integration Testing: A Comprehensive Guide Delve into the differences between unit and integration testing, and understand when and how to apply each for optimal results.

Good vs Bad Unit Tests: Tips for Making the Best Decision Learn to distinguish between well-written and poorly constructed unit tests, and how to improve the quality of your test suites.

Unit Testing in Python is Way More Convenient Than You’ve Thought Explore how Python's testing frameworks like unittest and pytest simplify the process of writing and managing unit tests.

How to Do Java Unit Testing Effectively Gain insights into best practices for unit testing in Java, including tools and methodologies to write effective tests.

[souhaillaghchimdev]

Test-Driven Development (TDD)

Test-Driven Development (TDD) is a software development approach where you write tests before writing the actual code. It may sound counterintuitive at first, but TDD can significantly improve code quality, maintainability, and confidence in your software. This post introduces the TDD process, benefits, and how to start applying it effectively in your projects.

What is TDD?

TDD is a development methodology where tests are written to define desired behavior before implementing the functionality. It follows a short and repetitive development cycle:

The TDD Cycle

Write a Test: Write a test that describes the expected behavior of a feature.

Run the Test: The test should fail because the feature doesn't exist yet.

Write the Code: Write just enough code to make the test pass.

Run the Test Again: Verify that it passes.

Refactor: Clean up the code while ensuring the test still passes.

Benefits of TDD

Better Code Design: Forces you to think about the interface before the implementation.

Fewer Bugs: Catches errors early and reduces regression.

Confidence in Changes: Tests act as a safety net when modifying code.

Documentation: Tests serve as living documentation of your code's expected behavior.

Example: TDD in Python

Let’s walk through a simple example where we build a function that adds two numbers using TDD.

1. Write the Test (Fail First)

# test_calculator.py from calculator import add def test_add(): assert add(2, 3) == 5

2. Run the Test

Since the add function doesn't exist yet, this test will fail.

3. Write the Function

# calculator.py def add(a, b): return a + b

4. Run the Test Again

The test now passes. ✅

5. Refactor (If Necessary)

No refactor needed in this simple case, but you might optimize or clean up code in more complex examples.

Popular Testing Frameworks

Python: pytest, unittest

JavaScript: Jest, Mocha

Java: JUnit

C#: NUnit, xUnit

Ruby: RSpec

Best Practices for TDD

Write small, focused tests.

Only write code needed to pass the test.

Run tests frequently as you code.

Refactor with confidence using passing tests as backup.

Use meaningful test names to document behavior.

Challenges of TDD

Initial learning curve for writing good tests.

May slow down early development if not practiced correctly.

Requires discipline and consistency across teams.

Conclusion

Test-Driven Development can significantly boost the quality and maintainability of your code. It leads to cleaner architecture, fewer bugs, and more confidence in your changes. By starting with tests, you're also writing code that’s naturally more testable and modular. Embrace TDD as a habit, and you'll become a smarter, more reliable programmer.

[netcode-hub]

💡Master Unit Testing in .NET 8 Blazor WebAssembly: xUnit, BUnit & Moq for CRUD Components🚀 https://youtu.be/D5BMnlEBAoY

[jcmarchi]

Best C# Testing Frameworks In 2024 - Technology Org

New Post has been published on https://thedigitalinsider.com/best-c-testing-frameworks-in-2024-technology-org/

Best C# Testing Frameworks In 2024 - Technology Org

Automation testing frameworks are essential in ensuring application performance and quality. C#  testing frameworks offer multiple features to meet various testing requirements. In this blog, we will explore the top C# testing frameworks of 2024.

Writing software code. Image credit: pxhere.com, CC0 Public Domain

C# testing Frameworks – Overview

The C# testing framework is a set of tools and an API that help construct, run, and manage the automation testing process in C# applications. Theses framework presents the developers with the systematic method to design and architect test suites so that the software works correctly and satisfies the given requirements.

C# testing frameworks typically offer features such as

Test case organization: Allow developers to group tests into logical units such as test classes or test suites for better organization and management.

Assertions: Build functions to state that the code has followed the desired sequence for the code under automation testing to make a program behave logically.

Setup and teardown: Support setup and teardown actions to correctly initialize the test environment before running tests and consequently clean up.

Test discovery and execution: Automatically execute and test the code and provide responses about test results and errors associated with the code.

Mocking and stubbing: Developers should be able to create mock objects to simulate dependencies and isolate units of code for automation testing.

Top C# Testing Frameworks In 2024

Let us see some of the top C# testing frameworks in 2024.

C# Selenium WebDriver

C# Selenium WebDriver is a framework for automation testing. It can process the navigation from the web page and detect its functions, performance, and user experience.

It also allows developers to write code and simulate user actions to verify elements on the web page. This allows for the creation of reliable automated tests that can be executed repeatedly to ensure the application’s behavior

Its cross-browser compatibility allows developers to write tests once and run them across multiple web browsers to ensure test coverage and compatibility with various user environments.

NUnit

The NUnit is a unit testing framework for languages like C# and VB.NET. It addresses the need for developers to write, manage, and run the unit test either within Visual Studio or through the command-line interface.

NUnit offers assertions, test runners, and attribute-based automation testing capabilities to validate the behavior of individual components. Its extensible architecture allows integration with various development tools and continuous integration pipelines that enable automation testing practices. NUnit supports parameterized tests, setup, teardown methods, and parallel test execution in automation testing. It remains the best framework for .NET developers to maintain code quality through unit testing.

MSTest

MSTest provides developers an efficient tool for writing and executing unit tests for .NET applications. MSTest can integrate with the IDE to create and manage unit tests effortlessly.

MSTest supports various testing features, such as test discovery, assertion methods, test execution, and result reporting, to effectively validate code’s behavior and functionality. It also offers attributes for defining test methods and classes to enhance the organization’s efficiency and maintainability.

It reduces the writing process and testing execution action and provides a wide user guide for most project types like .NET Core, .NET Framework, and Xamarin.

MSTest is integrated into the Microsoft Azure DevOps cloud platform to customize the unit cloud testing phase into automation testing and continuous feedback.

xUnit.NET

xUnit.NET follows the xUnit testing pattern, emphasizing simplicity, clarity, and extensibility. xUnit.NET provides developers a flexible platform for writing and executing unit tests to validate code functionality.

Its extensible architecture allows for easy integration with various development tools and frameworks. It also offers multiple assertion methods and test runners for a diverse set of testing scenarios.

xUnit.NET promotes test isolation, parallel test execution, and deterministic test outcomes. It supports test fixtures and setup/teardown methods. It can also encourage test-driven development (TDD) by integrating with popular IDEs. It also offers integration with continuous integration tools to incorporate unit testing into their CI/CD pipelines.

SpecFlow

SpecFlow is a BDD framework that uses natural language syntax for creating and writing scenarios, as well as the execution and management of acceptance tests for .NET software. It can be integrated with Visual Studio and other .NET development tools to enhance collaboration among developers and testers.

SpecFlow allows it to formulate executable specifications expressed in a human-comprehensible manner using the Gherkin syntax. These specifications can be added to the software documentation to maintain their functionality.

SpecFlow encourages collaboration and communication among cross-functional teams by defining a common language of application behavior expressed in a readable format. This approach also promotes code reusability and manageability by reusing the step definitions within many scenarios and features.

FluentAssertions

Fluent Assertions is the assertion library for .NET. It enables developers to write assertions in their unit test cases. It uses natural language that allows developers to identify assertions through the fluent interface.

It lets developers write assertion statements like natural language sentences to make the unit test easily understood. Such if-else statements held in the form of assertions can be written as “should” followed by a mentionable situation like “should be equal to” or “should contain,” showing what kind of behavior is expected for that tested code.

It supports various assertions like basic equality checks, collection assertions, and complex object comparisons. It also provides built-in support for asserting exceptions to verify that their code throws the expected exceptions under specific conditions. It also provides customizable assertion messages and failure descriptions.

Ranorex

Ranorex is an automation testing tool specially developed to make application testing of all platforms, including desktop, web, and mobile apps, easier and faster. Its graphical user interface (GUI) is so intuitive to create automated tests.

Unlike other testing tools, Ranorex has an object recognition capability that facilitates testers’ easy identification and interaction with UI elements, including buttons, text fields, and dropdown lists distributed across different platforms. This enables the development of automation testing, which precisely reproduces user interactions.

In addition, it provides built-in support for data-driven testing so they can easily write their test cases and execute them using different sets of data to ensure complete test coverage. It integrates with popular continuous integration and delivery tools that will automate the execution of the created tests as part of their build-up pipelines for continuous integration/delivery.

Its reporting capabilities offer a detailed assessment of the test results and common metrics needed. Testers can analyze the test results, identify problems, and track the progress of their testing activities by using customizable metrics.

BDDfy

BDDfy enables developers to implement Behavior-driven Driven Development practices in their .NET projects. BDDfy allows teams to focus on defining the behavior of their software through executable specifications written in natural language to establish collaboration between developers, testers, and stakeholders.

BDDfy also allows developers to write tests using natural language constructs to make the intent of the tests clear and understandable to all team members. This facilitates better communication and alignment of expectations throughout the development process.

The integration provides flexibility and versatility in test organization and execution, enabling teams to adopt BDD practices.

BDDfy provides detailed and insightful test reports that highlight the software’s behavior under test. These reports provide valuable documentation and can be shared with stakeholders to demonstrate progress and ensure alignment with requirements.

ApprovalTests

ApprovalTests is a versatile testing library designed to simplify verifying code output. ApprovalTests allows developers to approve the current behavior of their code by capturing and comparing its output against previously approved results.

Developers can quickly integrate ApprovalTests into their existing testing workflow regardless of the programming language or testing framework used. This makes it a valuable tool for various development environments like .NET, Java, Python, and more.

ApprovalTests improves handling complex output formats such as large data structures, images, and multi-line text. Developers can easily identify unexpected changes by capturing the code output and comparing it to approved results.

It effectively supports generating and managing approval files to review and update approved results as needed. This ensures that tests remain relevant and accurate over time.

NSubstitute

NSubstitute is a .NET mocking library constructed to simplify the process of creating and maintaining mock classes in unit testing. Mocking is a technique used in unit testing to simulate the behavior of dependencies in a component under test interactions with developers to isolate and test individual components.

NSubstitute expressive syntax enables developers to define mock objects and their behavior using natural language constructs. This makes it easy to understand and maintain mock setups.

NSubstitute supports various mocking scenarios and provides powerful features such as argument matches, callbacks, and received call verification to create flexible mock setups for unit tests.

The integration allows developers to use NSubstitute alongside their existing testing tools and practices without additional configuration.

NSpec

NSpec is a behavior-driven development testing framework for .NET developers designed to promote clarity, readability, and expressiveness in test specifications. It allows developers to write tests in a natural language format that closely resembles the software’s behavior specifications.

NSpec focuses on human-readable test specifications written using a syntax similar to plain English. This makes developers, testers, and stakeholders actively involved in the business and simplifies behavior definition and verification.

NSpec offers us features to do test management, such as grouping test cases under nested contexts, showing descriptive naming conventions, and a behavior-driven development paradigm. This allows developers to create clear and concise test specifications that accurately describe the expected behavior of the software under test. It also ensures compatibility and consistency across different testing environments, making adopting NSpec in existing projects easier.

Utilizing an automation testing framework tailored for C#, conducting automated testing for your website or mobile application becomes a straightforward task.

LambdaTest, an AI-powered test orchestration and execution platform, empowers you to execute manual and automated testing for your web projects on an extensive online browser farm featuring over 3000 real browsers, devices, and operating system configurations. Its cloud-based automation testing platform facilitates the execution of automation tests utilizing various C# testing frameworks such as Selenium, Appium, SpecFlow, NUnit, and others that help you test websites in different browsers.

Conclusion

In conclusion, C# testing frameworks in 2024 present developers with the right choices to meet various testing requirements. From NUnit’s strong focus on unit testing to SpecFlow’s emphasis on behavior-driven development, developers can access efficient tools for maintaining software quality. Whether the need is for unit testing or behavior-driven testing, these frameworks improve automation testing workflows and enhance the overall quality of C# applications.

[dangerousgalaxydonut]

Visual Studio For Mac Code Style

Visual Studio For Mac Code Style Check

Visual Studio For Mac Code Style In Eclipse

Developer Community for Visual Studio Product family. After version 7.6 All my Xamarin forms project won't reference.NET Portable Subset assemblies, breaking intellisene. Download Visual Studio Code to experience a redefined code editor, optimized for building and debugging modern web and cloud applications. Download Visual Studio Code - Mac, Linux, Windows This site uses cookies for analytics, personalized content and ads.

Develop apps and games for iOS, Android, and web using .NET

Code in C#, F#, Razor, HTML5, CSS, JavaScript, TypeScript, XAML, and XML

With the power of Roslyn, Visual Studio for Mac brings IntelliSense to your fingertips. IntelliSense describes APIs as you type and uses auto-completion to increase the speed and accuracy of how you write code.

Quick Info tool tips let you inspect API definitions, squiggly lines in the editor highlight issues, in real time as you type.

Use the Visual Studio debugger to quickly find and fix bugs across languages.

Visual Studio For Mac Code Style Check

The Visual Studio for Mac debugger lets you step inside your code by setting Breakpoints, Step Over statements, Step Into and Out of functions, and inspect the current state of the code stack through powerful visualizations.

As your project grows, chances are, you’ll find yourself restructuring and refactoring code that you or someone else wrote earlier. That’s a whole lot easier when Visual Studio for Mac takes care of the heavy lifting for you.

The Visual Studio for Mac editor supports powerful built-in refactoring options such as Extract Method and Rename, accessible via the Quick Actions menu.

Manage your code in Git or SVN repos hosted by any provider, including GitHub and Azure DevOps. Review diffs, stage files, and make commits from inside Visual Studio for Mac.

Enhance your code quality and create a solid code base with comprehensive testing tools. The integrated test runner supports major testing frameworks such as xUnit, NUnit, and MSTest, allowing you to efficiently run and debug unit tests and automated UI tests.

Choose the development environment that is right for you. With Visual Studio on both macOS and Windows, you can share your C# and F# projects seamlessly with your team using either OS.

Compare Visual Studio for Mac and PCFEATURESVisual Studio 2019 for MacVisual Studio 2019Web and cloud development using C#ASP.NET Core and .NET CorePublish to AzureAzure FunctionsAzure Connected ServicesDocker container toolsDesktop developmentWPF and Windows FormsUWPMac Apps using Xamarin and C#Console apps with C#Desktop apps using C++Mobile and gamingMobile development with .NET using Xamarin and C#Game development using Unity and C#Mobile and game development using C++Other workloads and toolsJavaPythonSQL Server data toolsNode.jsUnit testingVersion control with Git

Create cross-platform apps targeting Android and iOS using Xamarin

Build, manage, and deploy cloud apps that scale to Azure

Create and debug cross platform games and 3D real time applications with Unity

Customers using Xamarin with Visual Studio for Mac

Visual Studio For Mac Code Style In Eclipse

Launch a professional environment tailored to the Mac, free for most non-enterprise users

[thehardestwork]

HOW TO WRITE UNIT TESTS IN .NET

Unit testing is the idea of writing a separate set of code to automatically execute your production code and verify the results. It's called a 'unit' test because the idea is that you are only testing a single 'unit' of code and not the entire application. Writing Unit Tests is often seen in Test Driven Development but can and should be used in any development environment.

Unit tests give your application increased testing coverage with very little over-head. Most unit tests can execute extremely fast which means you can write hundreds of them and execute them all relatively quickly. In environments with multiple developers, unit tests can provide a sanity check for other developers making changes to existing code. But how do we actually go about writing a unit test?

In .NET there's a couple of ways we can do this. In Test Driven Development, you write your tests first. That sounds backwards but it's really about teaching your mind to think a certain way before you start writing any code because to write unit tests, you need highly decoupled code with few dependencies. When you do have dependencies you'll want to use Dependency Injection (which we can cover at another time).

The .NET stack provides a built in testing harness called MSTest. It gets the job done but doesn't come with the bells and whistles. I personally prefer xUnit which can be downloaded as a Nuget package. There is also NUnit which is very similar but I prefer xUnit because each execution of a test is containerized where as in NUnit all tests are run in a single container.

So once we've installed xUnit we can start writing our first tests. The first thing to do is to create a new project in your solution. We can do this by opening up our project in Visual Studio and then right-clicking on our solution, choosing Add, and then new project. From the 'Add a new project' window we can search for 'xUnit Test Project' and add that. I simply name the project 'Test' and click create.

By default a new class is created which contains your new test class. You should also see the 'Test Explorer' window in Visual Studio on the left-hand side. If you don't, go to the 'View' menu and select it. This menu contains all of your tests that you write and allows you to run them all or run them individually. You can also kick off a single test to debug it.

Now the fun part, writing a test! Let's keep it simple for starters and look at an example test:

[Fact] public void ItCanAddTwoNumbers() {   var result = AddTwoNumbers(1, 4);   Assert.Equal(5, result); }

So this test is doing a couple of things. By defining [Fact] we are saying this function is a test function and not some other helper function. I try to name my test functions based around what the application is trying to do like, 'ItCanAddTwoNumbers' but that is completely up to you.

Within the test function we can then call the function we want to test which in this case is 'AddTwoNumbers(int num1, int num2).' Simply calling this function and making sure the application doesn't crash or throw an error is already a little bit of test coverage which is great, but we can go farther. We can not only make sure it doesn't error, we can make sure we get the right results back.

We can do this using 'Assert' which gives us some different options for verifying the results are correct. In this case, our test will check to make sure the 'result' variable does equal 5. If it does, our test will pass with green colors. If not, our test will fail and show red in our Test Explorer. This is great when you already have some test written,  you make some code changes, and then re-run all of your tests to make sure everything is still working correctly.

One last tip, instead of using [Fact] we can use [Theory] to allow us to pass in multiple test values quickly like this:

[Theory] [InlineData(2)] [InlineData(5)] [InlineData(7)] public void ItCanAddOneToANumber(int number) {    var results = AddOneToNumber(number);    Assert.Equal(number + 1, results); }

Hopefully this gives you a brief introduction into how to write Unit Tests in .NET using xUnit. Unit testing will save you hours of debugging and troubleshooting time when that sneaky bug shows up that you can't quite track down. Even if the bug is not in your unit tests, it can help you track down the issue faster because you'll know it's not in any of your code that you have unit tests for.

Always test and happy coding!

[riya2019]

Build and Release DotNet online and classroom Training by DevopsSchool

DevOpsSchool is Provides Build and Release DotNet Training & Courses using Online and Classroom mode. Our Build and Release DotNet trainers are highly master in the area of Build and Release DotNet. We offer programs worldwide including Bangalore, Hyderabad, Pune, Mumbai, India, Netherlands, etc. Build and Release Dot net is a projects building management tools. Build and Release Dot Net supports deployment hosting system as server, PC, Mac, Laptop for perform. The Build and Release command is used to execute test framework on your projects as MSTest, NUnit or xUnit and get reports the success or failure on every test. In order to enhance the software quality, reducing cost and increased the productivity. Build and Release DotNet course is Designed to make you an expert in Build and Release Dot Net Engineer you learn how to deploy and manage the web software and source code control system with the help of training. Read more click here.

[keploy]

Unit Testing Frameworks: Choosing the Right One for Your Project

Unit testing is a critical practice in software development that ensures individual components function correctly. Choosing the right unit testing framework can streamline the testing process, enhance code quality, and reduce bugs in production. In this guide, we’ll explore the best unit testing frameworks across different programming languages and how tools like Keploy can enhance the testing experience.

What is Unit Testing?

Unit testing involves testing individual functions or modules of an application in isolation. These tests help developers catch errors early in the development process, ensuring that each component behaves as expected before integration with other parts of the system.

Why Use a Unit Testing Framework?

Manually writing and executing tests can be time-consuming and error-prone. A unit testing framework automates test execution, provides structured reporting, and integrates seamlessly into CI/CD pipelines. These frameworks enable developers to write efficient, maintainable, and repeatable tests, making the software development lifecycle smoother.

Key Features to Look for in a Unit Testing Framework

When choosing a unit testing framework, consider the following features:

Ease of Use: The framework should have a simple setup and an intuitive API.

Test Automation Support: Ability to run tests automatically in CI/CD workflows.

Assertion Capabilities: Strong assertion libraries to validate test results.

Mocking Support: Ability to mock dependencies for testing isolated components.

Compatibility: The framework should align with your programming language and project needs.

Popular Unit Testing Frameworks by Language

Python: pytest and unittest

pytest: A widely used testing framework with concise syntax, fixtures, and robust plugin support.

unittest: The built-in Python testing framework, offering structured test cases and assertions.

JavaScript: Jest and Mocha

Jest: A feature-rich framework by Facebook, providing built-in assertions, mocking, and snapshot testing.

Mocha: A flexible JavaScript testing framework that works with multiple assertion libraries like Chai.

Java: JUnit

JUnit: The standard unit testing framework for Java, offering annotations, parameterized tests, and assertions.

C#: NUnit and xUnit

NUnit: A popular framework for .NET, supporting parallel test execution and extensive assertion capabilities.

xUnit: A modern unit testing framework that improves test structure and readability.

Go: Testify

Testify: A lightweight framework for Go that enhances testing with easy-to-use assertions and mocking.

How Keploy Enhances Unit Testing

Keploy is an AI-powered unit testing tool that automatically generates test cases and mocks from real-world data. It helps developers achieve higher test coverage without the manual effort of writing tests. Key benefits of using Keploy include:

Automated Test Case Generation: Captures real API traffic and converts it into test cases.

Mocking & Simulation: Simulates user interactions and service responses for better test coverage.

Seamless CI/CD Integration: Works alongside existing unit testing frameworks to enhance automation.

How to Choose the Right Unit Testing Framework

The best unit testing framework depends on your language, project size, and testing requirements. Consider factors like:

Community Support: Frameworks with active communities receive frequent updates and support.

Integration Capabilities: Ensure it works well with your existing tools and CI/CD pipeline.

Ease of Adoption: Choose a framework with good documentation and an easy learning curve.

Conclusion Unit testing frameworks are essential for maintaining reliable software. By leveraging tools like Keploy alongside traditional frameworks, teams can streamline their testing efforts and ensure robust code quality. Selecting the right unit testing framework depends on your programming language, project needs, and automation goals—so choose wisely to optimize your development workflow.

[mattn]

.NET Core 3.0 が gRPC をサポートした。

「.NET Core 3.0」正式版が登場。Windowsデスクトップア��リ開発可能、exeファイルを生成、マイクロサービス対応など － Publickey

最新記事10本 Kafka開発元のConfluentに聞いた。エンタープライズ市場への道筋、大手クラウドとの現在の関係について 最大32コアのAMD EPYCプロセッサを搭載、コストパフォーマンスを高...

https://ift.tt/2mg6uiV

これまで通り、dotnet コマンドで SDK テンプレートを使って色々なアプリケーションを作成できる様になっている。dotnet 3.0 から使える SDK テンプレートは以下の通り。

使用法: new [options] オプション:   -h, --help          Displays help for this command.   -l, --list          Lists templates containing the specified name. If no name is specified, lists all templates.   -n, --name          The name for the output being created. If no name is specified, the name of the current directory is used.   -o, --output        Location to place the generated output.   -i, --install       Installs a source or a template pack.   -u, --uninstall     Uninstalls a source or a template pack.   --nuget-source      Specifies a NuGet source to use during install.   --type              Filters templates based on available types. Predefined values are "project", "item" or "other".   --dry-run           Displays a summary of what would happen if the given command line were run if it would result in a template creation.   --force             Forces content to be generated even if it would change existing files.   -lang, --language   Filters templates based on language and specifies the language of the template to create.   --update-check      Check the currently installed template packs for updates.   --update-apply      Check the currently installed template packs for update, and install the updates. Templates                                         Short Name               Language          Tags                                  ---------------------------------------------------------------------------------------------------------------------------------- Console Application                               console                  [C#], F#, VB      Common/Console                        Class library                                     classlib                 [C#], F#, VB      Common/Library                        WPF Application                                   wpf                      [C#]              Common/WPF                            WPF Class library                                 wpflib                   [C#]              Common/WPF                            WPF Custom Control Library                        wpfcustomcontrollib      [C#]              Common/WPF                            WPF User Control Library                          wpfusercontrollib        [C#]              Common/WPF                            Windows Forms (WinForms) Application              winforms                 [C#]              Common/WinForms                       Windows Forms (WinForms) Class library            winformslib              [C#]              Common/WinForms                       Worker Service                                    worker                   [C#]              Common/Worker/Web                     Unit Test Project                                 mstest                   [C#], F#, VB      Test/MSTest                           NUnit 3 Test Project                              nunit                    [C#], F#, VB      Test/NUnit                            NUnit 3 Test Item                                 nunit-test               [C#], F#, VB      Test/NUnit                            xUnit Test Project                                xunit                    [C#], F#, VB      Test/xUnit                            Razor Component                                   razorcomponent           [C#]              Web/ASP.NET                           Razor Page                                        page                     [C#]              Web/ASP.NET                           MVC ViewImports                                   viewimports              [C#]              Web/ASP.NET                           MVC ViewStart                                     viewstart                [C#]              Web/ASP.NET                           Blazor Server App                                 blazorserver             [C#]              Web/Blazor                            ASP.NET Core Empty                                web                      [C#], F#          Web/Empty                             ASP.NET Core Web App (Model-View-Controller)      mvc                      [C#], F#          Web/MVC                               ASP.NET Core Web App                              webapp                   [C#]              Web/MVC/Razor Pages                   ASP.NET Core with Angular                         angular                  [C#]              Web/MVC/SPA                           ASP.NET Core with React.js                        react                    [C#]              Web/MVC/SPA                           ASP.NET Core with React.js and Redux              reactredux               [C#]              Web/MVC/SPA                           Razor Class Library                               razorclasslib            [C#]              Web/Razor/Library/Razor Class Library ASP.NET Core Web API                              webapi                   [C#], F#          Web/WebAPI                            ASP.NET Core gRPC Service                         grpc                     [C#]              Web/gRPC                              dotnet gitignore file                             gitignore                                  Config                                global.json file                                  globaljson                                 Config                                NuGet Config                                      nugetconfig                                Config                                Dotnet local tool manifest file                   tool-manifest                              Config                                Web Config                                        webconfig                                  Config                                Solution File                                     sln                                        Solution                              Protocol Buffer File                              proto                                      Web/gRPC                              Examples:     dotnet new mvc --auth Individual     dotnet new --help

WinForms や WPF を使ったアプリケーションの開発もできる。すばらしい。

dotnet 3.0 で WinForms なアプリ動いた。 pic.twitter.com/46TkkM47SP

— mattn (@mattn_jp) September 24, 2019

以下の手順でアプリケーションを作成すると、SayHello というメソッドを持った Greeter サービスが作られる。

$ dotnet new grpc -o mygrpc

proto ファイルは以下の通り。

syntax = "proto3"; option csharp_namespace = "mygrpc"; package Greet; // The greeting service definition. service Greeter {   // Sends a greeting   rpc SayHello (HelloRequest) returns (HelloReply); } // The request message containing the user's name. message HelloRequest {   string name = 1; } // The response message containing the greetings. message HelloReply {   string message = 1; }

dotnet コマンドを使ってそのまま実行できる。

試しにこの proto ファイルから Go のクライアントを作って接続してみる。以下のコマンドで Go のクライアントが作られる。

$ go get github.com/golang/protobuf/protoc-gen-go $ protoc --go_out=plugins=grpc:. greet.proto

以下がそのクライアントを使ったサンプル。dotnet のサーバ側はポート 5000 番で通常ソケットの HTTP、5001 番で HTTP/2 で通信可能。dotnet run コマンドでは HTTP 通信のサーバは起動しないので dotnet build で��ルドし、bin 配下にある exe ファイルを実行する。この exe ファイル出力も今回の .NET Core 3.0 の新しい機能になる。

package main import (     "fmt"     "log"     pb "github.com/mattn/grpc-greeter/Greet"     "golang.org/x/net/context"     "google.golang.org/grpc" ) func main() {     conn, err := grpc.Dial("127.0.0.1:5000", grpc.WithInsecure())     if err != nil {         log.Fatal(err)     }     /*         opts = append(opts, grpc.WithTransportCredentials(creds))     */     defer conn.Close()     client := pb.NewGreeterClient(conn)     hello := &pb.HelloRequest{         Name: "おるみん",     }     result, err := client.SayHello(context.Background(), hello)     if err != nil {         log.Fatal(err)     }     fmt.Println(result.GetMessage()) }

実行すると以下の結果が得られる。

Hello おるみん

from Big Sky https://ift.tt/2msTsz2

[netcode-hub]

Goodbye Manual Testing🙋‍♂️, Welcome Automation!👋 Completely Master .NET Unit Testing with XUnit!🔥 https://youtu.be/NSGy8nkTiyQ