dolittle/DotNET.SDK

Method RunProcessorForeverUntilCancelled has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async Task RunProcessorForeverUntilCancelled<TIdentifier, TClientMessage, TServerMessage, TRegisterArguments, TRegisterResponse, TRequest, TResponse>(
        IEventProcessor<TIdentifier, TRegisterArguments, TRequest, TResponse> eventProcessor,
        IAmAReverseCallProtocol<TClientMessage, TServerMessage, TRegisterArguments, TRegisterResponse, TRequest, TResponse> protocol,
        CancellationToken cancellationToken)
        where TIdentifier : ConceptAs<Guid>

Method CreateConstruct has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    static Func<IServiceProvider, EventSourceId, Try<TAggregateRoot>> CreateConstruct(Type aggregateRootType)
    {
        if (!TryGetConstructor(aggregateRootType, out var constructor, out var e))
        {
            // Not instantiatable

Method FromConfiguration has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public static DolittleClientConfiguration FromConfiguration(Configurations.Dolittle config)
    {
        var result = new DolittleClientConfiguration();

        if (!string.IsNullOrEmpty(config.Runtime.Host))

Method Perform has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task<TResponse> Perform<TResponse>(Func<TAggregate, TResponse> method, CancellationToken cancellationToken = default)
    {
        if(cancellationToken == default)
        {
            cancellationToken = _defaultTimeout();

Method ReceiveAsync has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task ReceiveAsync(IContext context)
    {
        try
        {
            switch (context.Message)

Method Commit has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task<CommittedEvents> Commit(UncommittedEvents uncommittedEvents, CancellationToken cancellationToken = default)
    {
        using var activity = Tracing.ActivitySource.StartActivity()
            ?.Tag(uncommittedEvents);

Method CommitForAggregate has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task<CommittedAggregateEvents> CommitForAggregate(UncommittedAggregateEvents uncommittedAggregateEvents, CancellationToken cancellationToken = default)
    {
        using var activity = Tracing.ActivitySource.StartActivity()
            ?.Tag(uncommittedAggregateEvents);

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        var singlyBoundTypes = new SinglyBoundDeDuplicatedIdentifierMap<Type>(
            deDuplicatedTypes,
            (type, identifiers) =>
            {
                var sb = new StringBuilder();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        var singlyBoundProcessorBuilders = new SinglyBoundDeDuplicatedIdentifierMap<object>(
            deDuplicatedProcessorBuilders,
            (processorBuilder, identifiers) =>
            {
                var sb = new StringBuilder();

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (!eventType.HasEventTypeAttribute())
                {
                    context.ReportDiagnostic(Diagnostic.Create(
                        DescriptorRules.Events.MissingAttribute,
                        parameters[0].DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax().GetLocation(),

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (!eventType.HasEventTypeAttribute())
                {
                    context.ReportDiagnostic(Diagnostic.Create(
                        DescriptorRules.Events.MissingAttribute,
                        parameters[0].DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax().GetLocation(),

• Read up
  Read up

Method AddProtoCluster has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public static IServiceCollection AddProtoCluster(this IServiceCollection self, GetClusterKinds getClusterKinds)
    {
        self.AddSingleton(p =>
        {
            var loggerFactory = p.GetRequiredService<ILoggerFactory>();

Method Start has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task Start()
    {
        if (_started)
        {
            return;

Method RegistrationsFor has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<ServiceRegistration>> registrationAccessor)
    {
        if (service is not IServiceWithType serviceWithType)
        {
            return Enumerable.Empty<IComponentRegistration>();

Method AddProtoInfra has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public static IServiceCollection AddProtoInfra(this IServiceCollection services, GetClusterKinds getClusterKinds)
    {
        return AddProtoCluster(services, getClusterKinds)
            .AddSingleton<GetServiceProviderForTenant>(sp =>
            {

Method ParametersAreValid has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    internal static bool ParametersAreValid(MethodInfo method, [NotNullWhen(true)] out ProjectionParametersType? parametersType)
    {
        var parameters = method.GetParameters();
        parametersType = default;
        if (parameters.Length is 0 or > 2)

Method On has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    void On(CommittedEvent evt)
    {
        var eventType = evt.EventType;
        if (!_projection.Events.TryGetValue(eventType, out var keySelector))
        {

Method Perform has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public async Task Perform(Func<TAggregate, Task> method, CancellationToken cancellationToken = default)
    {
        if(cancellationToken == default)
        {
            cancellationToken = _defaultTimeout();

Method AddToContainer has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    void AddToContainer(TenantId tenantId, IServiceCollection serviceCollection)
    {
        foreach (var projection in Values)
        {
            var readModelType = projection.ProjectionType;

Method CheckOnReturnType has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    static void CheckOnReturnType(SyntaxNodeAnalysisContext context, INamedTypeSymbol projectionType, IMethodSymbol onMethod,
        MethodDeclarationSyntax syntax)
    {
        // Check for valid return type. Valid types are void, ProjectionResultType and ProjectionResult<>
        var returnType = onMethod.ReturnType;