Interoperating with C# and Other .NET Languages

using System.Diagnostics.CodeAnalysis;

namespace Shelf.Pricing;

// A positional record: Visual Basic sees a class with properties, a constructor and value equality.
public record Price(decimal Amount, string Currency);

// An init-only setter and a required member.
public sealed class Discount
{
    public required string Code { get; init; }
    public decimal Percent { get; init; }

    public Discount() { }

    [SetsRequiredMembers]
    public Discount(string code, decimal percent)
    {
        Code = code;
        Percent = percent;
    }
}

// A default interface method: the body lives in the interface.
public interface ILabel
{
    string Text { get; }
    string Upper() => Text.ToUpperInvariant();
}

public sealed class ShelfLabel : ILabel
{
    public string Text { get; init; } = "";
}

// An abstract base class that Visual Basic classes can derive from.
public abstract class Pricer
{
    public virtual string Name => "base pricer";
    public abstract decimal Compute(decimal basePrice);
}

Option Strict On

Imports Shelf.Pricing

Module RecordsAndInit
    Sub Run()
        Dim first = New Price(9.99D, "EUR")
        Dim second = New Price(9.99D, "EUR")
        Console.WriteLine(first.ToString())
        Console.WriteLine(first.Equals(second))
        Console.WriteLine(first = second)
        Console.WriteLine(ReferenceEquals(first, second))

        Dim amount As Decimal
        Dim currency As String = Nothing
        first.Deconstruct(amount, currency)
        Console.WriteLine(amount.ToString() & " " & currency)

        Dim spring = New Discount With {.Code = "SPRING", .Percent = 15D}
        Console.WriteLine(spring.Code & " " & spring.Percent.ToString())

        Dim autumn = New Discount("AUTUMN", 5D)
        Console.WriteLine(autumn.Code & " " & autumn.Percent.ToString())
    End Sub
End Module

Price { Amount = 9.99, Currency = EUR }
True
True
False
9.99 EUR
SPRING 15
AUTUMN 5

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim d = New Discount With {.Code = "A", .Percent = 1D}
        d.Code = "B"
        d.Percent = 2D
    End Sub
End Module

Program.vb(9,9): error BC37311: Init-only property 'Code' can only be assigned by an object member initializer, or on 'Me', 'MyClass` or 'MyBase' in an instance constructor.
Program.vb(10,9): error BC37311: Init-only property 'Percent' can only be assigned by an object member initializer, or on 'Me', 'MyClass` or 'MyBase' in an instance constructor.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim d = New Discount()
        Dim e = New Discount With {.Percent = 1D}
    End Sub
End Module

Program.vb(8,21): error BC37321: Required member 'Public Overloads Property Code As String' must be set in the object initializer or attribute arguments.
Program.vb(9,21): error BC37321: Required member 'Public Overloads Property Code As String' must be set in the object initializer or attribute arguments.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim price = New Price(9.99D, "EUR")
        Dim cheaper = price With {.Amount = 1D}
    End Sub
End Module

Program.vb(9,29): error BC30205: End of statement expected.

Option Strict On

Imports Shelf.Pricing

Public Class SeasonalPricer
    Inherits Pricer

    Public Overrides ReadOnly Property Name As String
        Get
            Return "seasonal (" & MyBase.Name & ")"
        End Get
    End Property

    Public Overrides Function Compute(basePrice As Decimal) As Decimal
        Return Math.Round(basePrice * 0.9D, 2)
    End Function
End Class

Public Class PlainLabel
    Implements ILabel

    Public ReadOnly Property Text As String Implements ILabel.Text
        Get
            Return "plain"
        End Get
    End Property

    ' Visual Basic classes must write the body of a default interface method themselves.
    Public Function Upper() As String Implements ILabel.Upper
        Return Text.ToUpperInvariant()
    End Function
End Class

Module InterfacesAndInheritance
    Sub Run()
        Dim label As ILabel = New ShelfLabel With {.Text = "abc"}
        Console.WriteLine(label.Upper())

        ' A Visual Basic implementation of the interface, with its own Upper.
        Dim plain As ILabel = New PlainLabel()
        Console.WriteLine(plain.Upper())

        Dim pricer As Pricer = New SeasonalPricer()
        Console.WriteLine(pricer.Name)
        Console.WriteLine(pricer.Compute(20D))
    End Sub
End Module

ABC
PLAIN
seasonal (base pricer)
18.0

Option Strict On

Imports Shelf.Pricing

Public Class PlainLabel
    Implements ILabel

    Public ReadOnly Property Text As String Implements ILabel.Text
        Get
            Return "plain"
        End Get
    End Property
End Class

Module Program
    Sub Main()
    End Sub
End Module

Program.vb(6,16): error BC30149: Class 'PlainLabel' must implement 'Function Upper() As String' for interface 'ILabel'.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim label As New ShelfLabel With {.Text = "abc"}
        Console.WriteLine(label.Upper())
    End Sub
End Module

Program.vb(9,27): error BC30456: 'Upper' is not a member of 'ShelfLabel'.

using System.Numerics;
using System.Runtime.CompilerServices;
using Shelf.Core;

namespace Shelf.Pricing;

public static class PriceMath
{
    // Ref returns, spans and params.
    public static ref int RefTo(int[] values, int index) => ref values[index];

    public static ref readonly int RefReadOnlyTo(int[] values, int index) => ref values[index];

    public static int SumSpan(ReadOnlySpan<int> values)
    {
        int sum = 0;
        foreach (int v in values) sum += v;
        return sum;
    }

    public static ReadOnlySpan<int> Head(int[] values) => values.AsSpan(0, 2);

    public static int Total(params int[] values) => values.Sum();

    public static int TotalSpan(params ReadOnlySpan<int> values) => SumSpan(values);

    // Generic constraints that Visual Basic cannot write itself.
    public static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
    {
        T total = T.Zero;
        foreach (T v in values) total += v;
        return total;
    }

    public static int SizeOf<T>() where T : unmanaged => Unsafe.SizeOf<T>();

    // Overload resolution priority (C# 13): the object overload wins for a string argument.
    [OverloadResolutionPriority(1)]
    public static string Prefer(object value) => "object (priority 1)";

    public static string Prefer(string value) => "string";

    // ByRef and Optional.
    public static void Swap<T>(ref T a, ref T b) => (a, b) = (b, a);

    public static bool TryRate(string key, out decimal rate)
    {
        rate = key == "EUR" ? 1.0m : 1.1m;
        return key.Length == 3;
    }

    public static int Optional(int a, int b = 10, string label = "n") => a + b + label.Length;

    // Tuples, nullable annotations and non-null parameters.
    public static (string Name, int Count) Stats(Catalog catalog) => ("catalog", catalog.Search("").Count());

    public static string? Find(string key) => key == "x" ? "found" : null;

    public static int LengthOf(string text) => text.Length;

    // Async.
    public static Task<Price> LoadAsync(decimal amount) => Task.FromResult(new Price(amount, "EUR"));

    public static async IAsyncEnumerable<int> CountAsync(int n)
    {
        for (int i = 1; i <= n; i++)
        {
            await Task.Yield();
            yield return i;
        }
    }

    public static dynamic MakeDynamic() => new System.Dynamic.ExpandoObject();
}

Option Strict On

Imports Shelf.Pricing

Module RefsSpansAndParams
    Sub Run()
        Dim numbers = New Integer() {1, 2, 3}

        ' A ref return can be read, and also written through.
        Dim copy As Integer = PriceMath.RefTo(numbers, 1)
        Console.WriteLine(copy)
        PriceMath.RefTo(numbers, 1) = 99
        Console.WriteLine(numbers(1))

        ' Spans: an array converts to ReadOnlySpan(Of Integer) at the call.
        Console.WriteLine(PriceMath.SumSpan(numbers))

        ' A returned span can be held in an inferred local; its indexer cannot be used.
        Dim head = PriceMath.Head(numbers)
        Console.WriteLine(head.Length)
        Console.WriteLine(String.Join(",", head.ToArray()))

        ' A params ReadOnlySpan parameter accepts an array, not a list of values.
        Console.WriteLine(PriceMath.TotalSpan(numbers))

        ' params Integer() is a ParamArray.
        Console.WriteLine(PriceMath.Total(1, 2, 3))
        Console.WriteLine(PriceMath.Total())
    End Sub
End Module

2
99
103
2
1,99
103
6
0

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim s As Span(Of Integer)
        Dim r As ReadOnlySpan(Of Integer)
    End Sub
End Module

Program.vb(8,18): error BC30668: 'Span(Of Integer)' is obsolete: 'Types with embedded references are not supported in this version of your compiler.'.
Program.vb(9,18): error BC30668: 'ReadOnlySpan(Of Integer)' is obsolete: 'Types with embedded references are not supported in this version of your compiler.'.
Program.vb(8,13): warning BC42024: Unused local variable: 's'.
Program.vb(9,13): warning BC42024: Unused local variable: 'r'.

Option Strict On

Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim numbers = New Integer() {1, 2, 3}
        Dim head = PriceMath.Head(numbers)
        Console.WriteLine(head(1))
        For Each n In head
            Console.WriteLine(n)
        Next
    End Sub
End Module

Program.vb(9,27): error BC30643: Property 'System.ReadOnlySpan(Of T).Item(index As Integer)' is of an unsupported type.
Program.vb(10,23): error BC30643: Property 'System.ReadOnlySpan(Of T).Enumerator.Current' is of an unsupported type.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Dim numbers = New Integer() {1, 2, 3}
        Dim v As Integer = PriceMath.RefReadOnlyTo(numbers, 0)
        Console.WriteLine(v)
    End Sub
End Module

Program.vb(9,38): error BC30657: 'RefReadOnlyTo' has a return type that is not supported or parameter types that are not supported.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Console.WriteLine(PriceMath.TotalSpan(1, 2, 3))
    End Sub
End Module

Program.vb(8,50): error BC30057: Too many arguments to 'Public Shared Overloads Function TotalSpan(values As ReadOnlySpan(Of Integer)) As Integer'.
Program.vb(8,47): error BC30311: Value of type 'Integer' cannot be converted to 'ReadOnlySpan(Of Integer)'.

namespace Shelf.Pricing;

public interface IParse<T> where T : IParse<T>
{
    static abstract T Parse(string text);
}

public readonly struct Cents : IParse<Cents>
{
    public int Value { get; }
    public Cents(int value) => Value = value;
    public static Cents Parse(string text) => new(int.Parse(text));
    public override string ToString() => Value + "c";
}

public static class Parser
{
    public static T ParseOne<T>(string text) where T : IParse<T> => T.Parse(text);
}

Option Strict On

Imports Shelf.Pricing

Module GenericsAndOverloads
    Sub Run()
        ' INumber(Of T) constraint, satisfied by Integer and Double.
        Console.WriteLine(PriceMath.Sum(New Integer() {1, 2, 3}))
        Console.WriteLine(PriceMath.Sum(New Double() {1.5, 2.25}))

        ' The unmanaged constraint, satisfied by value types without references.
        Console.WriteLine(PriceMath.SizeOf(Of Integer)())
        Console.WriteLine(PriceMath.SizeOf(Of Double)())

        ' Overload resolution priority is honoured since Visual Basic 17.13.
        Console.WriteLine(PriceMath.Prefer("text"))

        ' A static abstract interface member, called through a generic method.
        Dim cents = Parser.ParseOne(Of Cents)("250")
        Console.WriteLine(cents)
        Console.WriteLine(cents.Value)

        Dim a = 1
        Dim b = 2
        PriceMath.Swap(a, b)
        Console.WriteLine(a.ToString() & " " & b.ToString())

        Dim rate As Decimal
        Console.WriteLine(PriceMath.TryRate("EUR", rate).ToString() & " " & rate.ToString())
    End Sub
End Module

6
3.75
4
8
object (priority 1)
250c
250
2 1
True 1.0

Option Strict On

Imports Shelf.Pricing

Public Structure Euros
    Implements IParse(Of Euros)

    Public Shared Function Parse(text As String) As Euros Implements IParse(Of Euros).Parse
        Return New Euros()
    End Function
End Structure

Module Program
    Sub Main()
    End Sub
End Module

Program.vb(8,12): error BC30505: Methods or events that implement interface members cannot be declared 'Shared'.
Program.vb(6,16): error BC37315: Structure 'Euros' cannot implement interface 'IParse(Of Euros)' because it contains shared abstract or virtual 'Function Parse(text As String) As Euros'.

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Console.WriteLine(PriceMath.SizeOf(Of String)())
        Console.WriteLine(PriceMath.SizeOf(Of Date)())
    End Sub
End Module

Program.vb(8,37): error BC37332: Type argument 'String' must be a non-nullable value type, along with all fields at any level of nesting, in order to use it as type parameter 'T'.
Program.vb(8,37): error BC32105: Type argument 'String' does not satisfy the 'Structure' constraint for type parameter 'T'.

namespace Shelf.Pricing;

public static class StringExtensions
{
    // A classic extension method.
    public static string Shout(this string text) => text.ToUpperInvariant() + "!";

    // C# 14 extension block: the new syntax for extension members.
    extension(string text)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(text);
        public string Twice() => text + text;
    }
}

namespace Shelf.Pricing;

// Names that are keywords in Visual Basic.
public class KeywordNames
{
    public int End { get; set; } = 3;
    public string Error { get; set; } = "e";
    public string Class() => "class-method";
    public static string Select(string text) => "select:" + text;
}

public class Counter
{
    public event EventHandler<int>? Changed;
    public void Raise(int value) => Changed?.Invoke(this, value);

    // Indexers.
    public int this[int i] => i * 2;
    public int this[string s] => s.Length;
}

public delegate int Combine(int a, int b);

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module ExtensionsAndNames
    Sub Run()
        ' A classic extension method and a method from a C# 14 extension block.
        Console.WriteLine("abc".Shout())
        Console.WriteLine("ab".Twice())
        ' The extension property is a static accessor method for Visual Basic.
        Console.WriteLine(StringExtensions.get_IsBlank("  "))

        ' Members named like Visual Basic keywords are fine after a dot.
        Dim names As New KeywordNames()
        Console.WriteLine(names.End)
        Console.WriteLine(names.Error)
        Console.WriteLine(names.Class())
        Console.WriteLine(KeywordNames.Select("x"))

        ' Optional parameters keep their defaults.
        Console.WriteLine(PriceMath.Optional(1))
        Console.WriteLine(PriceMath.Optional(1, label:="long"))

        ' A tuple with names, and a string? result.
        Dim catalog = New Catalog(New MemoryStore())
        Dim stats = PriceMath.Stats(catalog)
        Console.WriteLine(stats.Name & " " & stats.Count.ToString())
        Console.WriteLine(PriceMath.Find("x"))
        Console.WriteLine(PriceMath.Find("y") Is Nothing)

        ' Nullable reference annotations are not enforced: Nothing compiles.
        Try
            Console.WriteLine(PriceMath.LengthOf(Nothing))
        Catch ex As NullReferenceException
            Console.WriteLine("NullReferenceException")
        End Try
    End Sub
End Module

Public Class MemoryStore
    Implements ICatalogStore

    Private ReadOnly _items As New List(Of CatalogItem)

    Public Function GetAll() As IReadOnlyList(Of CatalogItem) Implements ICatalogStore.GetAll
        Return _items
    End Function

    Public Sub Add(item As CatalogItem) Implements ICatalogStore.Add
        _items.Add(item)
    End Sub

    Public Function Find(id As Integer) As CatalogItem Implements ICatalogStore.Find
        Return _items.First(Function(i) i.Id = id)
    End Function
End Class

ABC!
abab
True
3
e
class-method
select:x
12
15
catalog 0
found
True
NullReferenceException

Option Strict On

Imports Shelf.Core
Imports Shelf.Pricing

Module Program
    Sub Main()
        Console.WriteLine("ab".Twice())
        Console.WriteLine("ab".IsBlank)
        Console.WriteLine(StringExtensions.Twice("ab"))
        Console.WriteLine(StringExtensions.get_IsBlank("  "))
    End Sub
End Module

Program.vb(9,27): error BC30456: 'IsBlank' is not a member of 'String'.

Option Strict On

Imports Microsoft.FSharp.Collections
Imports Shelf.Fs
Imports Shelf.Pricing

Module EventsAsyncAndFSharp
    Private Sub OnChanged(sender As Object, e As Integer)
        Console.WriteLine("Changed " & e.ToString())
    End Sub

    Private Async Function CountAsync() As Task
        Dim price = Await PriceMath.LoadAsync(5D)
        Console.WriteLine(price)

        ' There is no Await For Each: drive the async enumerator by hand.
        Dim iterator = PriceMath.CountAsync(3).GetAsyncEnumerator()
        Try
            While Await iterator.MoveNextAsync()
                Console.WriteLine(iterator.Current)
            End While
        Finally
            iterator.DisposeAsync().AsTask().GetAwaiter().GetResult()
        End Try
    End Function

    Sub Run()
        Dim counter As New Counter()
        AddHandler counter.Changed, AddressOf OnChanged
        counter.Raise(42)
        Console.WriteLine(counter(21))
        Console.WriteLine(counter("abcd"))

        Dim combine As New Combine(Function(a, b) a * b)
        Console.WriteLine(combine(6, 7))

        CountAsync().GetAwaiter().GetResult()

        Dim review = Rating.NewReview(5, "great")
        Console.WriteLine(Ratings.describe(review))
        Console.WriteLine(Ratings.describe(Rating.Unrated))
        Console.WriteLine(review.Tag)
        Console.WriteLine(Ratings.average(ListModule.OfSeq(New Integer() {4, 5, 3})))
        Console.WriteLine(Ratings.parse("12").Value)
        Console.WriteLine(Ratings.parse("x") Is Nothing)
    End Sub
End Module

Changed 42
42
4
42
Price { Amount = 5, Currency = EUR }
1
2
3
5 stars: great
unrated
2
4
12
True

namespace Shelf.Fs

type Rating =
    | Unrated
    | Stars of int
    | Review of stars: int * text: string

module Ratings =
    let describe (r: Rating) =
        match r with
        | Unrated -> "unrated"
        | Stars n -> sprintf "%d stars" n
        | Review (n, t) -> sprintf "%d stars: %s" n t

    let average (xs: int list) : float = List.averageBy float xs

    let parse (s: string) : int option =
        match System.Int32.TryParse s with
        | true, v -> Some v
        | _ -> None

Option Strict On

Imports Shelf.Pricing

Module Program
    Async Function RunAsync() As Task
        Await For Each n In PriceMath.CountAsync(3)
            Console.WriteLine(n)
        Next
    End Function

    Sub Main()
    End Sub
End Module

Program.vb(7,15): error BC30201: Expression expected.
Program.vb(9,9): error BC30092: 'Next' must be preceded by a matching 'For'.

Option Strict On

Imports System.Reflection
Imports Shelf.Core

Module OperatorNames
    Sub Run()
        ' A Visual Basic class that overloads operators: the metadata names C# sees.
        Dim flags = BindingFlags.Public Or BindingFlags.Static Or BindingFlags.DeclaredOnly
        For Each method In GetType(Money).GetMethods(flags).OrderBy(Function(m) m.Name)
            Console.WriteLine(method.Name)
        Next
    End Sub
End Module

op_Addition
op_Concatenate
op_Exponent
op_False
op_Implicit
op_IntegerDivision
op_Like
op_Modulus
op_True

Program.cs(4,20): error CS0019: Operator '^' cannot be applied to operands of type 'Money' and 'int'