-
Notifications
You must be signed in to change notification settings - Fork 1k
Scala to C# Conversion Guide
- Be .NET idiomatic, e.g. do not port
Duration
instead ofTimeSpan
andFuture
instead ofTask<T>
- Stay as close as possible to the original JVM implementation,
- Do not add features that don't exist in JVM Akka into the core Akka.NET
from
final case class HandingOverData(singleton: ActorRef, name: String)
simple implementation
public sealed class HandingOverData
{
public HandingOverData(IActorRef singleton, string name)
{
Singleton = singleton;
Name = name;
}
public IActorRef Singleton { get; }
public string Name { get; }
}
complex implementation
public sealed class HandingOverData
{
public HandingOverData(IActorRef singleton, string name)
{
Singleton = singleton;
Name = name;
}
public IActorRef Singleton { get; }
public string Name { get; }
private bool Equals(HandingOverData other)
{
return Equals(Singleton, other.Singleton) && string.Equals(Name, other.Name);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj)) return false;
if (ReferenceEquals(this, obj)) return true;
return obj is HandingOverData && Equals((HandingOverData)obj);
}
public override int GetHashCode()
{
unchecked
{
return ((Singleton?.GetHashCode() ?? 0) * 397) ^ (Name?.GetHashCode() ?? 0);
}
}
public override string ToString() => $"{nameof(HandingOverData)}<{nameof(Singleton)}: {Singleton}, {nameof(Name)}: {Name}>";
}
In order to support C# 7 deconstruction you could add Deconstruct
method
public void Deconstruct(out IActorRef singleton, out string name)
{
singleton = Singleton;
name = Name;
}
Some messages should implement With
(from C# 8 records spec) or Copy
method.
public HandingOverData With(IActorRef singleton = null, string name = null)
=> new HandingOverData(singleton ?? Singleton, name ?? Name);
In some cases it would be a good idea (mandatory for value types) to implement IEquatable<T>
public sealed class HandingOverData : IEquatable<HandingOverData>
{
...
public bool Equals(HandingOverData other)
{
return Equals(Singleton, other.Singleton) && string.Equals(Name, other.Name);
}
...
}
from
case object RecoveryCompleted
simple implementation
public sealed class RecoveryCompleted
{
public static RecoveryCompleted Instance { get; } = new RecoveryCompleted();
private RecoveryCompleted() {}
}
complex implementation
public sealed class RecoveryCompleted
{
public static RecoveryCompleted Instance { get; } = new RecoveryCompleted();
private RecoveryCompleted() {}
public override bool Equals(object obj) => !ReferenceEquals(obj, null) && obj is RecoveryCompleted;
public override int GetHashCode() => nameof(RecoveryCompleted).GetHashCode();
public override string ToString() => nameof(RecoveryCompleted);
}
In some cases it would be a good idea (mandatory for value types) to implement IEquatable<T>
public sealed class RecoveryCompleted : IEquatable<RecoveryCompleted>
{
...
public bool Equals(RecoveryCompleted other) => true;
...
}
scala | C# |
---|---|
collectFirst(func) | FirstOrDefault(func) |
drop(count) | Skip(count) |
dropRight(count) | Reverse().Skip(count).Reverse() |
exists(func) | Any(func) |
filter(func) | Where(func) |
filterNot(func) | <none> |
flatMap(func) | SelectMany(func) |
flatten | SelectMany(i => i) |
fold(initval)(func) | <none> |
foldLeft(initval)(func) | Aggregate(initval, func) |
foldRight(initval)(func) | Reverse().Aggregate(initval, func) |
forall(func) | All(func) |
foreach(func) | <none> |
head | First() |
headOption | FirstOrDefault() |
last | Last() |
lastOption | LastOrDefault() |
map(func) | Select(func) |
mkString(separator) | string.Join(separator, array) |
reduce(func) | <none> |
reduceLeft(func) | Aggregate(func) |
reduceRight(func) | Reverse().Aggregate(func) |
sorted(implicit ordering) | OrderBy(i -> i, comparer) |
tail | Skip(1) |
take(count) | Take(count) |
takeRight(count) | Reverse().Take(count).Reverse() |
zip(seq2, func) | Zip(seq2, func) |
zipWithIndex | <none> |
from
def bufferOr(grouping: String, message: Any, originalSender: ActorRef)(action: ⇒ Unit): Unit = {
buffers.get(grouping) match {
case None ⇒ action
case Some(messages) ⇒
buffers = buffers.updated(grouping, messages :+ ((message, originalSender)))
totalBufferSize += 1
}
}
to
public void BufferOr(string grouping, object message, IActorRef originalSender, Action action)
{
BufferedMessages messages = null;
if (_buffers.TryGetValue(grouping, out messages))
{
_buffers[grouping].Add(new KeyValuePair<object, IActorRef>(message, originalSender));
_totalBufferSize += 1;
}
else {
action();
}
}
scala | C# |
---|---|
IllegalArgumentException | ArgumentException |
IllegalStateException | InvalidOperationException |
ArithmeticException | ArithmeticException |
NullPointerException | NullReferenceException |
NotSerializableException | SerializationException |
def testPattern(x: Any): String = x match {
case 0 => "zero"
case true => "true"
case "hello" => "you said 'hello'"
case Nil => "an empty List"
}
C# 7 supports all constant patterns
public string TestPattern(object x)
{
switch(x)
{
case 0: return "zero";
case true: return "true";
case "hello": return "you said Hello";
case null: return "an empty list";
}
return string.Empty;
}
def testPattern(x: Any): String = x match {
case List(0, _, _) => "a three-element list with 0 as the first element"
case List(1, _*) => "a list beginning with 1, having any number of elements"
case Vector(1, _*) => "a vector starting with 1, having any number of elements"
}
C# does not support sequence patterns
def testPattern(x: Any): String = x match {
case (a, b) => s"got $a and $b"
case (a, b, c) => s"got $a, $b, and $c"
}
C# does not support tuples patterns
def testPattern(x: Any): String = x match {
case Person(first, "Alexander") => s"found an Alexander, first name = $first"
case Dog("Suka") => "found a dog named Suka"
}
C# does not support constructor patterns. But you could use an equivalent
public string TestPattern(object x)
{
switch(x)
{
case Person p when p.LastName == "Alexander": return $"found an Alexander, first name = {p.FirstName}";
case Dog d when d.Name == "Suka": return "found a dog named Suka";
}
return string.Empty;
}
def testPattern(x: Any): String = x match {
case s: String => s"you gave me this string: $s"
case i: Int => s"thanks for the int: $i"
case f: Float => s"thanks for the float: $f"
case a: Array[Int] => s"an array of int: ${a.mkString(",")}"
case as: Array[String] => s"an array of strings: ${as.mkString(",")}"
case d: Dog => s"dog: ${d.name}"
case list: List[_] => s"thanks for the List: $list"
case m: Map[_, _] => m.toString
}
You can use typed patterns in C#7
public string TestPattern(object x)
{
switch(x)
{
case string s: return $"you gave me this string: {s}";
case int i: return $"thanks for the int: {i}";
case float f: return $"thanks for the float: {f}";
case int[] a: return $"an array of int: {string.Join(",", a)}";
case Dog d: return $"dog: ${d.Name}";
case List<int> list: return $"thanks for the List: {list}";
case Dictionary<int, string> dict: return $"dictionary: {dict}";
}
return string.Empty;
}
trait User {
def name: String
}
class FreeUser(val name: String) extends User
class PremiumUser(val name: String) extends User
object FreeUser {
def unapply(user: FreeUser): Option[String] = Some(user.name)
}
object PremiumUser {
def unapply(user: PremiumUser): Option[String] = Some(user.name)
}
// using
val user: User = new PremiumUser("Daniel")
user match {
case FreeUser(name) => "Hello " + name
case PremiumUser(name) => "Welcome back, dear " + name
}
public interface IUser
{
string Name { get; }
}
public class FreeUser : IUser
{
public FreeUser(string name)
{
Name = name;
}
public string Name { get; }
}
public class PremiumUser : IUser
{
public PremiumUser(string name)
{
Name = name;
}
public string Name { get; }
}
public static class UserExtensions
{
public static bool TryExtractName(this IUser user, out string name)
{
name = user.Name;
return !string.IsNullOrEmpty(user.Name);
}
}
// using
IUser user = new PremiumUser("Alex");
switch (user)
{
case PremiumUser p when p.TryExtractName(out var name):
Console.WriteLine(name);
break;
}
case class AllForOneStrategy(maxNrOfRetries: Int, withinTimeRange: Duration)
C# equivalent. All constructor parameters should be transformed to public properties
public class AllForOneStrategy
{
public AllForOneStrategy(int maxNumberOfRetries, TimeSpan withinTimeRange)
{
MaxNumberOfRetries = maxNumberOfRetries;
WithinTimeRange = withinTimeRange;
}
public int MaxNumberOfRetries { get; }
public TimeSpan WithinTimeRange { get; }
}
require(cost > 0, "cost must be > 0")
use ArgumentException
if (cost <= 0) throw ArgumentException("cost must be > 0", nameof(cost));
- Traits
- Partial functions
- Local functions/Nested Methods
- Tail call recursion
- For Comprehensions
- Default Parameter Values
- Implicit parameters
- Prefer to use
FluentAssertions
in tests, instead ofXunit assertions
andAkkaSpecExtensions
Akka uses intecept to check that an exception was thrown
intercept[IllegalArgumentException] {
val serializer = new MiscMessageSerializer(system.asInstanceOf[ExtendedActorSystem])
serializer.manifest("INVALID")
}
in C# you have 2 options
var serializer = new MiscMessageSerializer(Sys.AsInstanceOf<ExtendedActorSystem>());
// use FluentAssertions
Action comparison = () => serializer.Manifest("INVALID");
comparison.ShouldThrow<ArgumentException>();
// use Xunit2 asserts
Assert.Throws<ArgumentException>(() => serializer.Manifest("INVALID"));