C#

codewitch honey crisis wrote:

greatly expand the surface area of your interconnected class APIs

Bernhard Hiller wrote:

C#

Task task = new Task(() => RemoteChannelProvider.Call(_channel => _channel.SetInfraredFocus(_clientName, _focus)));

1. SetInfraredFocus returns a Task;
2. Call may or may not discard that task;
3. Even if it doesn't discard the task, the new Task constructor definitely discards it - none of the overloads accept a Func<Task>;
4. The task returned from the client therefore doesn't observe the result of the task returned from the server. It could even complete before the server call has finished.

public Task SetInfraredFocus(string _clientName, double _focus)
{
    return Task.Run(() => RemoteChannelProvider.Call(_channel => _channel.SetInfraredFocus(_clientName, _focus)));
}

public delegate void CallProxyDelegate<in T>(T _channel);
...
void Call(CallProxyDelegate<T> _codeBlock, [CallerMemberName] string _functionName = "");

m_ConfigurationChannelFactory = new ConfigurationDuplexChannelFactory<T>(m_CallbackObject, ConfigurationName, null, config);
...
m_CommunicationChannel = (ICommunicationObject)m_ConfigurationChannelFactory.CreateChannel();
...
_codeBlock((T)m_CommunicationChannel);

public Task SetInfraredFocus(string _clientName, double _focus)
{
    return Task.Run(delegate
    {
        Task result = null;
        RemoteChannelProvider.Call(_channel => result = _channel.SetInfraredFocus(_clientName, _focus));
        return result;
    });
}

BillWoodruff wrote:

C#

TKey key = default(TKey)

public TKey GetNextKey(TKey key = default)

BillWoodruff wrote:

C#

if (! KeysUsed.Contains(key))
{
    CurrentKey = key;
    KeysUsed.Add(key);
    return key;
}

if (KeysUsed.Add(key))
{
    CurrentKey = key;
    return key;
}

BillWoodruff wrote:

C#

switch (KeyType)

public class Foo<TKey>
{
    private readonly HashSet<TKey> KeysUsed;
    private readonly Func<TKey, TKey> GenerateNextKey;
    
    public Foo(Func<TKey, TKey> generateNextKey, IEqualityComparer<TKey> comparer = default)
    {
        if (generateNextKey is null) throw new ArgumentNullException(nameof(generateNextKey));
        
        GenerateNextKey = generateNextKey;
        KeysUsed = new HashSet<TKey>(comparer ?? EqualityComparer<TKey>.Default);
    }
    
    public TKey CurrentKey { get; private set; }
    
    public TKey GetNextKey(TKey key = default)
    {
        while (!KeysUsed.Add(key))
        {
            key = GenerateNextKey(key);
        }
        
        CurrentKey = key;
        return key;
    }
}

public static class Foo
{
    public static class Int32
    {
        public static readonly Func<int, int> GenerateNextKey = i => i + 1;
        
        public static Foo<int> Create() => new Foo<int>(GenerateNextKey);
    }
    
    public static class String
    {
        public static readonly Func<string, string> GenerateNextKey = s => s + GetAGuid();
        
        private static string GetAGuid() => Guid.NewGuid().ToString("N");
        
        public static Foo<string> Create(IEqualityComparer<string> comparer = default) => new Foo<string>(GenerateNextKey, comparer);
    }
}

Foo<int> fooInt = Foo.Int.Create();
Foo<string> fooString = Foo.String.Create(StringComparer.OrdinalIgnoreCase);
Foo<Guid> fooGuid = new Foo<Guid>(_ => Guid.NewGuid());