IChannel interface seems to have a `internal` member now (2025.7.1-0136-g42c85d3d1e)

[antokhio]

https://github.com/vvvv/VL.StandardLibs/blob/40e399b90fc6fdf5382ecfd7e100901a8aa9048c/VL.Core/src/Reactive/Channel.cs#L104C9-L104C72

Hi, there seems to be an issue in the IChannel interface now:

public interface IChannel : IHasAttributes, IDisposable
{
    // ...
    internal IChannel<Spread<Attribute>> AttributesChannel { get; }
}

No sure if it's intended for interface member to have an internal flag, making this interface unimplementable.

However the purpose of this issue, is: can we have please have an inheritable channel in the core, what I mean is something like this:

public class MyCustomChannel : Channel<object> {
    // my custom other stuff here
}

The problem that currently I had to fully mimic channel, by routing it's members:

   public abstract class ChannelBase<T> : IChannel<T>, IDisposable
   {
       protected readonly IChannel<T> _internalChannel;

       protected ChannelBase(IChannel<T> internalChannel)
       {
           _internalChannel = internalChannel;
       }

       public T? Value
       {
           get => _internalChannel.Value;
           set => _internalChannel.Value = value;
       }

       public void SetValueAndAuthor(T? value, string? author) =>
           _internalChannel.SetValueAndAuthor(value, author);

       public Func<T?, Optional<T?>>? Validator
       {
           set => _internalChannel.Validator = value;
       }

       public Type ClrTypeOfValues => _internalChannel.ClrTypeOfValues;
       public ImmutableArray<object> Components
       {
           get => _internalChannel.Components;
           set => _internalChannel.Components = value;
       }
       public IChannel<object> ChannelOfObject => _internalChannel.ChannelOfObject;
       public bool Enabled
       {
           get => _internalChannel.Enabled;
           set => _internalChannel.Enabled = value;
       }
       public bool IsBusy => _internalChannel.IsBusy;
       public object? Object
       {
           get => _internalChannel.Object;
           set => _internalChannel.Object = value;
       }
       public string? LatestAuthor => _internalChannel.LatestAuthor;

       public void SetObjectAndAuthor(object? @object, string? author) =>
           _internalChannel.SetObjectAndAuthor(@object, author);

       public IDisposable BeginChange() => _internalChannel.BeginChange();

       public string? Path => _internalChannel.Path;
       public int Revision => _internalChannel.Revision;
       public AccessorNodes AccessorNodes => _internalChannel.AccessorNodes;
       public bool IsInitialized => _internalChannel.IsInitialized;
       public bool HasBeenRequested => _internalChannel.HasBeenRequested;

       public bool HasValue => _internalChannel.HasValue;
       public bool AcceptsValue => _internalChannel.AcceptsValue;

       // Added implementation for the missing interface member
       internal IChannel<Spread<Attribute>> AttributesChannel => null;

       IMonadicValue<T> IMonadicValue<T>.SetValue(T? value) =>
           ((IMonadicValue<T>)_internalChannel).SetValue(value);

       public void OnCompleted() => _internalChannel.OnCompleted();

       public void OnError(Exception error) => _internalChannel.OnError(error);

       public void OnNext(T? value) => _internalChannel.OnNext(value);

       public IDisposable Subscribe(IObserver<T?> observer) =>
           _internalChannel.Subscribe(observer);

       public Spread<Attribute> Attributes => _internalChannel.Attributes;

       private bool _disposed;

       public virtual void Dispose()
       {
           if (_disposed)
               return;
           _disposed = true;
           _internalChannel.Dispose();
       }
   }

But with this latest change I can't compile anyhow, anymore:

public IChannel<Spread<Attribute>> AttributesChannel => _internalChannel.AttributesChannel;

'ChannelBase<T>.AttributesChannel.get' cannot implicitly implement an inaccessible member.

@gregsn can we please make the interface member public

[gregsn]

hey antokhio,

I made that member public. For now, I didn't make the IChannel implementations public as I wasn't sure about the proper separation of concerns. Can you elaborate why you had to implement it yourself?

The idea was that it should be sufficient to let us create channels via ChannelHelpers.CreateChannelOfType.
Thanks for the feedback!

[antokhio]

For example in Avalonia there is no native Vector2 input (e.g. textbox or slider) so I have to do something like:

  public class Vector2ChannelProperty : ChannelProperty<Vector2>
  {
      public IChannel<float?> XChannel { get; }
      public IChannel<float?> YChannel { get; }
      public Optional<Vector2> Minimum { get; }
      public Optional<Vector2> Maximum { get; }

      public class Vector2ChannelProperty(Vector2? intialValue):base(VL.Lib.Reactive.Channel.Create(intialValue)){
           var synchronizer = Observable.Merge(....);
      }
}

This also comes handy when you have structures similar to object editors, e.g:

public ControlPointChannelPoint : Vector2ChannelProperty {}

// And somewhere else:

Control = channelProperty switch {
    Vector2ChannelProperty v2cp => new Vector2PropertyEditor(v2cp);
    ControlPointChannelPoint cpcp => new ControlPointPOropertyEditor(cpc);
}
// note: this is pseudo code, it's done via patch normally

This way I can implement logic on top of the channel, and have vl see it as an Channel, witch reduces amount of bloat.

[gregsn]

Is ChannelProperty<T> implementing IChannel<T>?

I wasn't able to find that class in your code-base, and in your example code I don't see the channel implementation.

Was hoping that you could do these kinds of things without the need of implementing the channel yourself.

[antokhio]

It's going to be quite a bit of codebase:

// Base class
public abstract class ChannelBase<T> : InstancedId, IChannel<T>, IDisposable
{
    protected IChannel<T> _internalChannel;

    protected ChannelBase(IChannel<T> internalChannel)
    {
        _internalChannel = internalChannel;
    }

    public T? Value
    {
        get => _internalChannel.Value;
        set => _internalChannel.Value = value;
    }

    public void SetValueAndAuthor(T? value, string? author) =>
        _internalChannel.SetValueAndAuthor(value, author);

    public Func<T?, Optional<T?>>? Validator
    {
        set => _internalChannel.Validator = value;
    }

    public Type ClrTypeOfValues => _internalChannel.ClrTypeOfValues;
    public ImmutableArray<object> Components
    {
        get => _internalChannel.Components;
        set => _internalChannel.Components = value;
    }
    public IChannel<object> ChannelOfObject => _internalChannel.ChannelOfObject;
    public bool Enabled
    {
        get => _internalChannel.Enabled;
        set => _internalChannel.Enabled = value;
    }
    public bool IsBusy => _internalChannel.IsBusy;
    public object? Object
    {
        get => _internalChannel.Object;
        set => _internalChannel.Object = value;
    }
    public string? LatestAuthor => _internalChannel.LatestAuthor;

    public void SetObjectAndAuthor(object? @object, string? author) =>
        _internalChannel.SetObjectAndAuthor(@object, author);

    public IDisposable BeginChange() => _internalChannel.BeginChange();

    public string? Path => _internalChannel.Path;
    public int Revision => _internalChannel.Revision;
    public AccessorNodes AccessorNodes => _internalChannel.AccessorNodes;
    public bool IsInitialized => _internalChannel.IsInitialized;
    public bool HasBeenRequested => _internalChannel.HasBeenRequested;

    public bool HasValue => _internalChannel.HasValue;
    public bool AcceptsValue => _internalChannel.AcceptsValue;

    IMonadicValue<T> IMonadicValue<T>.SetValue(T? value) =>
        ((IMonadicValue<T>)_internalChannel).SetValue(value);

    public void OnCompleted() => _internalChannel.OnCompleted();

    public void OnError(Exception error) => _internalChannel.OnError(error);

    public void OnNext(T? value) => _internalChannel.OnNext(value);

    public void EnsureValue(T? value, bool force = false, string? author = null) =>
        _internalChannel.EnsureValue(value, force, author);

    public IDisposable Subscribe(IObserver<T?> observer) =>
        _internalChannel.Subscribe(observer);

    public Spread<Attribute> Attributes => _internalChannel.Attributes;

    private bool _disposed;

    public virtual void Dispose()
    {
        if (_disposed)
            return;
        _disposed = true;
        _internalChannel.Dispose();
    }
}

// Channel Property
public interface IChannelProperty : IChannel
{
    string Name { get; }
    bool IsValid { get; }
}

public interface IIChanelProperty<T> : IChannelProperty, IChannel<T>
{
    void SetChannel(IChannel<T> channel);
}

public class ChannelProperty<T> : ChannelInteractable<T>, IIChanelProperty<T>
{
    public string Name { get; protected set; }

    public ChannelProperty(
        string name,
        T initialValue,
        Action<T?>? onChange = null,
        Action<T?>? onChanged = null,
        TimeSpan? throttleInterval = null,
        Func<T?, object[]?>? validator = null
    )
        : base(VLChannel.Create(initialValue), onChange, onChanged, throttleInterval, validator)
    {
        Name = name;
    }
}

public static class ChannelPropertyExtensions
{
    public static IIChanelProperty<T> WithChannel<T>(
        this IIChanelProperty<T> input,
        IChannel<T> channel
    )
    {
        input.SetChannel(channel);

        return input;
    }
}

// Rest of the bases
public abstract class ChannelInteractable<T> : ChannelValidatable<T>
{
    public static readonly TimeSpan DefaultThrottleInterval = TimeSpan.FromMilliseconds(200);
    public bool IsChanging { get; protected set; }

    private Action<T?>? _onChange;
    private Action<T?>? _onChanged;

    private IDisposable? _onChangeSubscription;
    private IDisposable? _onChangedSubscription;

    private readonly TimeSpan _throttleInterval;

    private readonly AppHost _appHost = AppHost.Current;

    public ChannelInteractable(
        IChannel<T> internalChannel,
        Action<T?>? onChange,
        Action<T?>? onChanged,
        TimeSpan? throttleInterval,
        Func<T?, object[]?>? validator
    )
        : base(internalChannel, validator)
    {
        _onChange = onChange;
        _onChanged = onChanged;

        _throttleInterval = throttleInterval ?? DefaultThrottleInterval;

        _onChangeSubscription = this.Subscribe(value =>
        {
            _onChange?.Invoke(value);

            IsChanging = true;
        });

        _onChangedSubscription = this.Throttle(_throttleInterval)
            .ObserveOn(SafeScheduler.CurrentSynchronizationContext)
            .Subscribe(value =>
            {
                using (_appHost.MakeCurrent())
                {
                    _onChanged?.Invoke(value);
                    IsChanging = false;

                    SyncSubChannelsInternal(value);
                }
            });
    }

    private void SyncSubChannelsInternal(T? value)
    {
        if (IsSyncing)
            return;
        IsSyncing = true;
        try
        {
            SyncSubChannels(value);
        }
        finally
        {
            IsSyncing = false;
        }
    }

    protected virtual void SyncSubChannels(T? value) { }

    protected virtual void SyncMainChannel(T? value)
    {
        if (IsSyncing)
            return;

        IsSyncing = true;
        try
        {
            this.OnNext(value);
        }
        finally
        {
            IsSyncing = false;
        }
    }

    public override void Dispose()
    {
        _onChange = null;
        _onChanged = null;

        _onChangeSubscription?.Dispose();
        _onChangedSubscription?.Dispose();

        base.Dispose();
    }
}

    public class ChannelValidatable<T> : ChannelSettable<T>
    {
        public object[]? Errors { get; protected set; }
        public bool IsValid => Errors is null || Errors.Length == 0;

        private IDisposable _validationSubscription;
        private Func<T?, object[]?>? _validator;

        public ChannelValidatable(IChannel<T> internalChannel, Func<T?, object[]?>? validator)
            : base(internalChannel)
        {
            _validator = validator;

            _validationSubscription = this.Subscribe(value =>
            {
                if (_validator != null)
                    Errors = _validator(value);
                else
                    Errors = null;
            });
        }

        public override void Dispose()
        {
            _validationSubscription?.Dispose();

            base.Dispose();
        }
    }

public abstract class ChannelSettable<T> : ChannelBase<T>
{
    public bool IsSyncing { get; protected set; }

    private IChannel<T>? _upstreamChannel;
    private CompositeDisposable? _upstreamChannelSubscription;

    public ChannelSettable(IChannel<T> internalChannel)
        : base(internalChannel) { }

    public void SetChannel(IChannel<T> channel)
    {
        if (ReferenceEquals(_upstreamChannel, channel))
            return;

        _upstreamChannelSubscription?.Dispose();

        _upstreamChannel = channel;

        if (_upstreamChannel is null)
            return;

        var upstreamToInternal = _upstreamChannel.Subscribe(next =>
        {
            if (IsSyncing)
                return;

            IsSyncing = true;
            try
            {
                _internalChannel.OnNext(next);
            }
            finally
            {
                IsSyncing = false;
            }
        });

        var internalToUpstream = _internalChannel.Subscribe(next =>
        {
            if (IsSyncing)
                return;
            IsSyncing = true;
            try
            {
                _upstreamChannel.OnNext(next);
            }
            finally
            {
                IsSyncing = false;
            }
        });

        if (
            EqualityComparer<T>.Default.Equals(_internalChannel.Value, _upstreamChannel.Value)
            is false
        )
        {
            IsSyncing = true;
            try
            {
                _internalChannel.OnNext(_upstreamChannel.Value);
            }
            finally
            {
                IsSyncing = false;
            }
        }

        _upstreamChannelSubscription = [upstreamToInternal, internalToUpstream];
    }

    public override void Dispose()
    {
        _upstreamChannelSubscription?.Dispose();

        base.Dispose();
    }
}

// Actual channel
public class RectangleFChannelProperty : ChannelProperty<RectangleF>
{
    public IChannel<float?> XChannel { get; }
    public IChannel<float?> YChannel { get; }
    public IChannel<float?> WidthChannel { get; }
    public IChannel<float?> HeightChannel { get; }

    private CompositeDisposable _subscriptions = new();

    public RectangleFChannelProperty(
        string name,
        RectangleF initialValue,
        Action<RectangleF>? onChange = null,
        Action<RectangleF>? onChanged = null,
        TimeSpan? throttleInterval = null,
        Func<RectangleF, object[]?>? validator = null
    )
        : base(name, initialValue, onChange, onChanged, throttleInterval, validator)
    {
        XChannel = VLChannel.Create((float?)initialValue.Center.X);
        YChannel = VLChannel.Create((float?)initialValue.Center.Y);
        WidthChannel = VLChannel.Create((float?)initialValue.Width);
        HeightChannel = VLChannel.Create((float?)initialValue.Height);

        _subscriptions.Add(
            XChannel.Subscribe(x =>
            {
                if (x != Value.Center.X)
                    SyncMainChannel(Value.SetCenter(Value.Center with { X = x ?? 0f }));
            })
        );

        _subscriptions.Add(
            YChannel.Subscribe(y =>
            {
                if (y != Value.Center.Y)
                    SyncMainChannel(Value.SetCenter(Value.Center with { Y = y ?? 0f }));
            })
        );
        _subscriptions.Add(
            WidthChannel.Subscribe(width =>
            {
                if (width != Value.Width)
                    SyncMainChannel(Value with { Width = width ?? 0f });
            })
        );
        _subscriptions.Add(
            HeightChannel.Subscribe(height =>
            {
                if (height != Value.Height)
                    SyncMainChannel(Value with { Height = height ?? 0f });
            })
        );
    }

    protected override void SyncSubChannels(RectangleF value)
    {
        XChannel.EnsureValue(value.Center.X);
        YChannel.EnsureValue(value.Center.Y);
        WidthChannel.EnsureValue(value.Width);
        HeightChannel.EnsureValue(value.Height);
    }

    public override void Dispose()
    {
        _subscriptions?.Dispose();

        XChannel?.Dispose();
        YChannel?.Dispose();
        WidthChannel?.Dispose();
        HeightChannel?.Dispose();

        base.Dispose();
    }
}

note: that's something I end up with at some point, but I don't really like the implementation, the case that handles, it's quite large object with a lot of interconnected properties. The throttled stuff goes in to model submition undo/redo, and the reactive stuff updates items on screen. At list the internal synchronization should be redone in favor of Merge.

[gregsn]

Nice!
It looks like you operate on a level where it is fine to implement IChannel yourself.

[gregsn]

So with newest update of StdLibs you can compile again, right?

[antokhio]

Yes it’s compiling.

Still would be good to avoid ChannelBase (like one I have right now), like same as with IChannel interface, I don’t wanna really care how it’s implemented since it’s provided, I want to just to be able to append functionality on it directly, if I want to fit it to some particular case...

[gregsn]

Ok, in this case you'd not implement IChannel yourself. Thus, I can keep

        internal IChannel<Spread<Attribute>> AttributesChannel { get; }

in the interface declaration.
My hope would be that this leads to better interoperability with IChannel interface of 7.0, where this property wasn't part of the interface at all.

[antokhio]

Well I would strongly advise against making property on public interface internal, instead whole interface should be marked as internal.

If you want explicit compatibility prolly you need:

internal IChannelWithAttributes : IChannel

Or some similar constraint (like adding it to base class)...

I can't really imagine that adding an interface member would break backwards compatibility (not sure if it's added or changed).

Should prolly evaluate against some potential bug case. Or wait for someone to hit this with actual reproducible example...

So my 50 cent would be keep it public as it is right now and look forward...

[gregsn]

Let's see if we hit a wall there.
But for me, it's fine. Interface is public as it is a type that gets used everywhere. Implementation, however, currently only doable in CoreLib, which is also something I'm happy with for now.

So anyway, aside from that detail:
You now can inherit from class Channel<T> and you get the std behavior.

[antokhio]

Hi, finally manage to give that a spin and, it seems there is some "shadowing" happening over IChannel, and IChannel
If I just use Channel as base, it has some missing methods. So I had to fallback to ChannelBase<T> : Channel<T>
Then I noticed that now SetValue, and Value returns object in vvvv.

So this my current test approach (notice something commented crashes vvvv completely)

 public abstract class ChannelBase<T> : Channel<T>
 {
     //// Explicitly shadow Value to ensure it is strongly typed as T?
     //// and takes precedence over implicit/explicit interface implementations.
     public new T? Value
     {
         get => base.Value;
         set => base.Value = value;
     }

     // Expose EnsureValue as a convenient instance method
     public void EnsureValue(T? value, bool force = false, string? author = default)
     {
         ChannelHelpers.EnsureValue(this, value, force, author);
     }

     // Expose OnNext with author support
     public void OnNext(T? value, string? author = default)
     {
         this.SetValueAndAuthor(value, author);
     }

     //// Forward standard IObserver methods
     //public void OnCompleted()
     //{
     //    ((IObserver<T?>)this).OnCompleted();
     //}

     //public void OnError(Exception error)
     //{
     //    ((IObserver<T?>)this).OnError(error);
     //}

     // Helper for simple subscription
     public IDisposable Subscribe(Action<T?> onNext)
     {
         return ((IObservable<T?>)this).Subscribe(Observer.Create(onNext));
     }

     // Forward standard Subscribe
     public IDisposable Subscribe(IObserver<T?> observer)
     {
         return ((IObservable<T?>)this).Subscribe(observer);
     }

     //// Expose Dispose publicly (it is explicit in the base class)
     //public new void Dispose()
     //{
     //    ((IDisposable)this).Dispose();
     //}

     //// Optional: Expose Revision if needed (it is explicit in base)
     //public int Revision => ((IChannel)this).Revision;
 }

Will get back to you when I do more tests, seems more props should be exposed on Channel so it inherits properly.

[antokhio]

My results of "more extended testing"
I made a repo so it's easier to follow.

So there is a "shadowing" issue in IChannel vs IChannel<T>. I can fix it by using a small base class
Also it fixes few inaccessible methods like MyCustomChannelInstance.OnNext(..) or .Subscribe()

You can see illustration of "shadowing issue" in the patch:

So... I'm happy with result currently, but as for public API it seems it needs bit more alignment...

Added also a code view test

The question is should we provide extendable base, or should we check if we can align Channel a bit...