Principles of developing a limited-queue mass service system on the .NET platform

Antonova Polina Valerevna Senior Lecturer of the Department of Intelligent Systems and Information Resource Management of Kazan National Research Technological University 420015, Russia, Republic of Tatarstan, Kazan, Karl Marx str., 68 valerevna.p@inbox.ru

Introduction

Queuing theory plays a key role in the analysis and optimization of processes related to the servicing of application flows in various fields, such as telecommunications, transport, healthcare and manufacturing ^{[1, 2]}. Let's consider the basic concepts of queuing theory and types of service systems. 

Fixed queue systems: In fixed queue systems, the number of places in the queue is limited. The ordering tasks concern determining the order in which applications will be served. The main ordering strategies include FIFO (First In, First Out), LIFO (Last In, First Out) and Priority maintenance. 

Single-channel and multi-channel systems with failures: in single-channel systems there is only one service channel. If the request arrives when the channel is busy, it can be rejected or queued. Multi-channel systems have several service channels, which allows you to process several applications simultaneously. If all channels are busy, the application can also be rejected or queued.

Systems with unlimited and limited waiting for service: in systems with unlimited waiting, applications can wait for service indefinitely. In systems with limited waiting, there are restrictions on queue length or waiting time. If the application cannot be served within these limits, it is rejected. 

Closed systems: In closed systems, applications are returned to the system after maintenance. This is often found in scenarios where resources are circulating in the system and can be reused. 

Multichannel systems with inter-channel interaction: In some multichannel systems, channels can interact with each other, dynamically allocating resources and exchanging information to improve service efficiency. This is important in complex network environments where different channels can handle different types of requests and a flexible response to changes in workload is needed.

Various mathematical models and methods such as Markov processes, queue theory and simulation are used to analyze queuing systems and determine optimal service strategies. Markov processes allow us to describe random processes with discrete states, queue theory focuses on the characteristics of request flows and service channels, and simulation modeling allows us to study the behavior of the system in various conditions. 

Knowledge and understanding of queuing theory are of high practical importance. For example, in telecommunications it helps to optimize network resources, in healthcare it helps to reduce patient waiting times, and in manufacturing it helps to increase productivity and reduce costs ^{[3, 4]}.

Queuing systems with a limited queue are an important subclass in queuing theory. They are characterized by the presence of an upper limit on the number of applications that can wait for service in the queue. As soon as this limit is reached, all subsequent applications will be rejected until a place in the queue is vacated ^[5].

Let's imagine aspects of queuing systems with a limited queue:

– Queue: A queue is a data structure that stores requests awaiting service. In systems with a limited queue, the number of applications in the queue cannot exceed a certain level, known as queue capacity.

– Service strategies: Systems with a limited queue can use various service strategies, such as FIFO (first come, first served), LIFO (last come, first served) or priority service, where some requests may take priority over others.

– M/M/c/K model: One of the most well–known models of systems with a limited queue is the M/M/c/K model. In this model, the time intervals between the receipt of requests and the service time are assumed to be exponential (denoted by the letter 'M'), 'c' denotes the number of service channels, and 'K' - the total number of places in the system (the number of places in the queue plus the number of channels).

– Performance analysis: various indicators are used to analyze the performance of systems with a limited queue, such as the probability of blocking (the probability of rejecting a new application), the average waiting time in the queue and the average number of applications in the system ^[6].

– Application: Queue-limited systems are widely used in various fields, such as telecommunications (for call management), network routers (for data packet management), healthcare (for patient flow management) and manufacturing (for optimization of production lines). For example, in telecommunications, queue-limited systems can be used to manage incoming calls in a call center. When all operators are busy and the queue has reached its maximum capacity, subsequent calls can be redirected to an automatic voice response system or receive a failure message. In the field of healthcare, systems with a limited queue can be used in emergency departments, where patients can be admitted according to the level of urgency of their condition. When the queue reaches its maximum capacity, patients with less urgent conditions can be referred to other medical institutions.

– Challenges and optimization strategies: One of the key challenges in systems with a limited queue is balancing between the service level and resources. Too small a queue can lead to frequent failures, while too large a queue can lead to inefficient use of resources. Optimization of such systems often comes down to choosing the appropriate queue size and number of service channels, as well as choosing an effective service strategy. Simulation modeling and analytical methods, such as queue theory, can be used to analyze and optimize system performance in various scenarios. 

Queuing systems with a limited queue play an important role in many areas where it is necessary to effectively manage the flow of applications. Optimization of such systems is a complex task that requires analysis and the use of specialized tools and methods. 

The article presents the principles of implementing single - channel and multi - channel CFR with a limited queue on the platform .NET using the C# programming language.

The relevance of the application of the platform .NET for implementing queuing systems with a limited queue in the C# programming language can be considered from several points of view:

– C# is a high-performance programming language, and a platform.NET provides modern tools and libraries for optimizing work with data and resources. This allows you to create high-performance QMS capable of processing a large number of applications with minimal delays.

– Platform .NET and C# provide built-in support for multithreading and parallel computing ^{[7, 8]}. This is especially true for CFOs, where it is often necessary to process several applications in parallel and coordinate the work of several service channels.

– .NET provides a wide range of libraries and tools that can be used in the development of CFR. This includes libraries for working with mathematical models, statistical analysis, simulation modeling and other tools necessary for the effective design of queuing systems.

– Platform .NET supports cross-platform deployment, which allows you to develop applications that can run on different operating systems without changing the code. This adds flexibility to the deployment and scaling of QMS in different environments.

– C# is known for its clean syntax and strict typing, which contributes to writing readable and maintainable code ^[9]. This facilitates the development of complex systems, such as CFR, and reduces the cost of their support and development.

Principles of developing a single-channel CFR with a limited queue

A single-channel queuing system with a limited queue is an important model used in various fields, from telecommunications to healthcare. 

To demonstrate the implementation of this type of CFR using the platform .NET and the C# programming language consider a simple example of a single-channel CFR with a maximum queue capacity of 5.

First, let's create a SingleServerQueue class that will encapsulate the CFR logic.

public?class?SingleServerQueue
{
private?Queue?queue;
private?int?maxQueueLength;
private?bool?isServerBusy;
public?SingleServerQueue(int?maxQueueLength)
{
this.queue?=?new?Queue();
this.maxQueueLength?=?maxQueueLength;
this.isServerBusy?=?false;
}
public?bool?EnqueueCustomer(Customer?customer)
{
if?(queue.Count?<?maxQueueLength)
{
queue.Enqueue(customer);
return?true;
}
return?false;
}
public?void?DequeueCustomer()
{
if?(queue.Count?>?0)
{
queue.Dequeue();
if?(queue.Count?==?0)
{
isServerBusy?=?false;
}
}
}?
//?Additional?methods?and?properties
}

Now that we have the main class, let's create a simulation. 

class?Program?
{?
static?void?Main(string[]?args)?
{?
SingleServerQueue?singleServerQueue?=?new?SingleServerQueue(5);
for?(int?i?=?0;?i?<?10;?i++)?
{?
Customer?customer?=?new?Customer();?
bool?isEnqueued?=?singleServerQueue.EnqueueCustomer(customer);
if?(isEnqueued)?
{?
Console.WriteLine($"Customer?{i}?is?enqueued.");?
}?
else?
{?
Console.WriteLine($"Customer?{i}?is?rejected.");?
}?
}?
}?
}?

In this code example, we create an instance of a single-channel CFR with a maximum queue length of 5 and try to add 10 clients. 

After creating a basic simulation, an important step is the analysis and optimization of the CFR. In C#, you can use various libraries and tools for performance analysis, such as profilers and tools for working with statistical data.

public?void?ProcessCustomers()
{?
while?(queue.Count?>?0)
{?
Customer?customer?=?queue.Peek();?
if?(IsServiceCompleted(customer))?
{?
DequeueCustomer();?
}?
}?
}?
private?bool?IsServiceCompleted(Customer?customer)?
{?
//?Logic?definitions?completed?if?service?client?
}?

In the code snippet above, we add methods for processing clients in the queue and checking for service completion. This can be expanded by using statistical methods to analyze waiting times, service efficiency, and other metrics.

Due to the object-oriented nature of C#, it is easy to extend and modify the CFR by adding new functionality or modifying existing ones. For example, you can add queue priority support, implement scheduling algorithms, or integrate with external data sources. 

When creating a real CFR application, it is also important to provide a user interface. Using .NET it is possible to create both console and graphical user interfaces (GUI), which allows you to create convenient tools for monitoring and managing CFR.

Principles of developing a multichannel CFR with a limited queue

In modern conditions, when many processes require optimization and parallelization, multi-channel queuing systems are becoming more and more relevant. They are used in various industries: from telecommunications to logistics. This fragment of the scientific article discusses the principles of developing a multi - channel CFR with a limited queue on the platform .NET using the C# programming language. 

The main components of the CFR are service channels and a queue. In C#, you can use classes and collections to model these components. For example, a queue can be represented using the Queue collection, and service channels can be represented using a list of channel objects.

public?class?ServiceChannel
{
public?bool?IsBusy?{?get;?set;?}
//?other?properties?and?methods
}
public?class?MultiChannelQueueSystem
{
private?Queue?queue?=?new?Queue();
private?List?serviceChannels?=?new?List();
public?MultiChannelQueueSystem(int?numberOfChannels)
{
for?(int?i?=?0;?i?<?numberOfChannels;?i++)
{
serviceChannels.Add(new?ServiceChannel());
}
}
//?other?methods
}

Processing of applications in a multi-channel CFR includes adding applications to the queue and their subsequent processing by available channels. 

public?void?EnqueueCustomer(Customer?customer)
{
if?(queue.Count?<?MaxQueueLength)
{
queue.Enqueue(customer);
}
}
public?void?ProcessQueue()
{
foreach?(ServiceChannel?channel?in?serviceChannels)
{
if?(!channel.IsBusy?&&?queue.Count?>?0)
{
Customer?customer?=?queue.Dequeue();
//?Processing of?application?on?channel
}
}
}

After modeling a multi-channel CFR, it is important to analyze its operation. This may include monitoring queue waiting times, channel loading, and other parameters. 

Using object-oriented approaches (OOP) approaches in C#, you can create flexible and reusable components, which will allow you to easily adapt the system to different conditions and requirements. For example, you can implement a base class for a service channel and inherit it for special types of channels.

public?class?ServiceChannel
{
public?virtual?bool?IsBusy?{?get;?set;?}
//?other?properties?and?methods
}
public?class?PriorityServiceChannel?:?ServiceChannel
{
public?override?bool?IsBusy
{
get
{
//?Custom?logic?for?priority?channel
}
set?{?/*?...?*/?}
}
}

You can also add events and delegates to handle various scenarios in the system, such as queue overflow alerts. 

Since multichannel CFR involves simultaneous servicing of several applications, it is important to use multithreading effectively ^[10]. In C#, this can be done using the Task Parallel Library (TPL). 

public?void?ProcessQueue()
{
Parallel.ForEach(serviceChannels,?(channel)?=>
{
if?(!channel.IsBusy?&&?queue.Count?>?0)
{
Customer?customer?=?queue.Dequeue();
//?Processing of?application?on?channel
}
});
}

When developing a QMS, it is important to conduct testing and validation to verify the correctness of the system. This can be done using unit tests and integration testing. 

Development of a multi - channel queuing system with a limited queue on the platform .NET using C# allows you to create efficient and flexible solutions. Thanks to the capabilities of OOP, multithreading and powerful libraries, C# is an excellent choice for implementing complex QMS that can adapt to changing requirements and conditions.

Practical use

Queuing systems are actively used in various fields, from telecommunications to finance ^{[11, 12]}. In this part of the article , we will look at examples of practical implementation of single - channel and multi - channel CFR with a limited queue on the platform .NET using C#.

To model a single-channel CFR with a limited queue, create the SingleChannelQueueSystem class.

public?class?SingleChannelQueueSystem
{
private?Queue?queue?=?new?Queue();
private?bool?isChannelBusy?=?false;
private?readonly?int?maxQueueLength;
public?SingleChannelQueueSystem(int?maxQueueLength)
{
this.maxQueueLength?=?maxQueueLength;
}
public?void?EnqueueCustomer(Customer?customer)
{
if?(queue.Count?<?maxQueueLength)
{
queue.Enqueue(customer);
}
}
public?void?ProcessQueue()
{
if?(!isChannelBusy?&&?queue.Any())
{
var?customer?=?queue.Dequeue();
isChannelBusy?=?true;
//?Processing?of the client
isChannelBusy?=?false;
}
}
}

Usage example:

SingleChannelQueueSystem?queueSystem?=?new?SingleChannelQueueSystem(5);
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.ProcessQueue();

To model a multichannel CFR, create the MultiChannelQueueSystem class.

public?class?MultiChannelQueueSystem
{
private?Queue?queue?=?new?Queue();
private?List?serviceChannels;
private?readonly?int?maxQueueLength;
public?MultiChannelQueueSystem(int?numberOfChannels,?int?maxQueueLength)
{
serviceChannels?=?new?List(new?bool[numberOfChannels]);
this.maxQueueLength?=?maxQueueLength;
}
public?void?EnqueueCustomer(Customer?customer)
{
if?(queue.Count?<?maxQueueLength)
{
queue.Enqueue(customer);
}
}
public?void?ProcessQueue()
{
for?(int?i?=?0;?i?<?serviceChannels.Count;?i++)
{
if?(!serviceChannels[i]?&&?queue.Any())
{
var?customer?=?queue.Dequeue();
serviceChannels[i]?=?true;
//?Processing?of the client
serviceChannels[i]?=?false;
}
}
}
}

Usage example:

MultiChannelQueueSystem?queueSystem?=?new?MultiChannelQueueSystem(3,?10);
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.ProcessQueue();

After creating the basic CFR models, it is important to analyze their performance and correctness of work. Using profiling tools such as Visual Studio Profiler will help identify bottlenecks and optimize the code.

Parallelization can be used to improve the performance of a multi-channel CFR. This can be done using the Task Parallel Library (TPL) in C#.

public?void?ProcessQueueParallel()
{
Parallel.For(0,?serviceChannels.Count,?i?=>
{
if?(!serviceChannels[i]?&&?queue.Any())
{
var?customer?=?queue.Dequeue();
serviceChannels[i]?=?true;
//?Processing?of the client
serviceChannels[i]?=?false;
}
});
}

Testing and validation of the system is necessary to ensure the accuracy and reliability of the simulation. To do this, you can use unit tests and testing tools such as MSTest, NUnit or xUnit.

Example of a unit test:

[TestClass]
public?class?QueueSystemTests
{
[TestMethod]
public?void?TestSingleChannelQueueSystem()
{
var?queueSystem?=?new?SingleChannelQueueSystem(5);
queueSystem.EnqueueCustomer(new?Customer());
queueSystem.ProcessQueue();
//?Checking?the conditions?(e.g.?the correct?amount?filings?in?queue)
}
}

Single-channel and multi-channel queuing systems can be applied in various fields, such as telecommunications, banking, logistics, etc. In particular, they can be used to optimize customer waiting times, resource allocation, and improve overall system performance.

Conclusion

The development of queuing systems with a limited queue is a complex process that includes modeling, analysis, optimization and creation of a user interface. Application of modern technologies and tools available within the framework of the platform.NET, allows you to create efficient and scalable solutions that can cope with real tasks in various industries. 

The article highlights the key aspects of the development, modeling and practical implementation of CFR using technologies.NET and the C# language. A detailed examination of single-channel and multi-channel systems, their features, principles of operation and methods of implementation is carried out. 

In addition to the considered aspects, there are a number of directions for further research and development of queuing systems:

– Integration with artificial intelligence: with the use of artificial intelligence, it is possible to improve decision-making processes in the system, for example, to predict the flow of applications and dynamically change system parameters to optimize service.

– Using cloud technologies: Integration with cloud platforms can provide increased availability, scalability and reliability of the system, as well as reduce infrastructure costs.

– Advanced analytics and visualization: The development of data analytics and visualization tools will allow system administrators and users to monitor and analyze the progress of maintenance more effectively and use this information to optimize processes.

– Ensuring security: Data and transaction security is a key aspect in modern queuing systems ^{[13, 14]}. The development and integration of protection mechanisms against unauthorized access and malicious software is an important part of creating a reliable system.