Play Store Application link – Java to .NET in 9 Steps – App on Google Play

Switching from Java to C# can feel like moving to a familiar yet slightly different neighborhood. Both languages share many similarities due to their object-oriented nature, but they also have distinct features and frameworks. This blog post will explore key comparisons between C# and Java, focusing on syntax, language features, frameworks, and data access libraries.

Language Features Comparison

C# vs. Java Syntax and Features

Both C# and Java have similar syntax due to their C-based lineage, but there are notable differences in features and syntax.

Basic Syntax

Here’s a simple example to highlight basic syntax differences:

Java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

C#:

using System;

public class HelloWorld {
    public static void Main(string[] args) {
        Console.WriteLine("Hello, World!");
    }
}

Properties

In Java, you typically use getter and setter methods for properties:

Java:

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

C# simplifies this with properties:

C#:

public class Person {
    public string Name { get; set; }
}

Language Features

1. Linq:
   LINQ (Language Integrated Query) in C# allows for querying collections in a SQL-like manner. Java lacks a direct equivalent, although Streams API provides similar functionality.
   C#:
   var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evens = numbers.Where(n => n % 2 == 0).ToList();
   
   Java:
   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evens = numbers.stream() .filter(n -> n % 2 == 0).collect(Collectors.toList());
   
2. Async/Await: C# has built-in support for asynchronous programming with async and await keywords, whereas Java introduced a similar concept with CompletableFuture and later Project Loom.
   
   C#:
   public async Task<int> FetchDataAsync() {
var result = await httpClient.GetStringAsync("http://example.com"); return int.Parse(result);
}
   
   Java:
   public CompletableFuture<Integer> fetchDataAsync() {
return CompletableFuture.supplyAsync(() -> {
try {
String result = httpClient.get("http://example.com").body();
return Integer.parseInt(result);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}

Framework Comparison

Spring vs. ASP.NET Core

Both Spring and ASP.NET Core are powerful frameworks for building web applications, but they have different approaches and ecosystems.

1. Dependency Injection:
   Both frameworks provide built-in support for dependency injection.
   Spring:
   @Service public class MyService {
private final MyRepository repository;
@Autowired public MyService(MyRepository repository) {
this.repository = repository;
}
}
   
   ASP.NET Core:
   public class MyService {
private readonly MyRepository _repository;
public MyService(MyRepository repository) {
_repository = repository;
}
}
2. MVC Pattern:
   Both frameworks support the Model-View-Controller (MVC) architectural pattern.
   
   Spring MVC:
   @Controller public class MyController {
@GetMapping("/hello")
public String hello(Model model) {
model.addAttribute("message", "Hello, World!");
return "hello";
}
}
   
   ASP.NET Core MVC:
   public class MyController : Controller {
[HttpGet("/hello")]
public IActionResult Hello() {
ViewData["Message"] = "Hello, World!";
return View();
}
}
   
3. Configuration:
   Configuration in Spring is typically managed with application.properties or application.yml, whereas ASP.NET Core uses appsettings.json.
   
   Spring: server.port=8080 spring.datasource.url=jdbc:mysql://localhost:3306/myDb
   
   ASP.NET Core: {
"ConnectionStrings": {
"DefaultConnection": "Server=myServer;Database=myDb;User=myUser;Password=myPass;"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning"
}
}
}

Data Access Libraries

Hibernate vs. Entity Framework Core

Hibernate and Entity Framework Core (EF Core) are the primary ORM (Object-Relational Mapping) tools for Java and C#, respectively.

1. Mapping Entities:
   Hibernate (Java):
   @Entity
   public class Product {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
private BigDecimal price;
// getters and setters
   }
   
   EF Core (C#):
   public class Product {
   public int Id { get; set; }
   public string Name { get; set; }
   public decimal Price { get; set; }
   }
   public class AppDbContext : DbContext {
   public DbSet Products { get; set; }
   protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseSqlServer("Server=myServer;Database=myDb;User=myUser;Password=myPass;"); }
   }
   
2. CRUD Operations:
   Hibernate (Java):
   @Repository
   public class ProductRepository {
   @Autowired
   private EntityManager entityManager;
   public Product save(Product product) { entityManager.persist(product); return product; } public Product findById(Long id) { return entityManager.find(Product.class, id); }
   }
   
   EF Core (C#):
   public class ProductRepository {
   private readonly AppDbContext _context;
   public ProductRepository(AppDbContext context) { _context = context; } public Product Save(Product product) { _context.Products.Add(product); _context.SaveChanges(); return product; } public Product FindById(int id) { return _context.Products.Find(id); }
   }

Summary

Transitioning from Java to C# involves understanding both the similarities and differences between the two languages and their ecosystems. By comparing language features, frameworks, and data access libraries, you can leverage your existing Java knowledge to become proficient in C#. Whether it’s using LINQ instead of Streams, deploying with IIS instead of Tomcat, or managing configurations with appsettings.json instead of application.properties, you’ll find the transition smoother with these parallels in mind. Happy coding!