LMSPro 10.4.0

LMS Framework Core

LMS Framework Core is the core library of LMS Framework - a powerful framework for building modern web applications with ASP.NET Core. This framework provides essential features such as Dependency Injection, Module System, Event Bus, Caching, Auditing, and many other features.

🚀 Key Features

🏗️ Module Architecture

• Module System: Flexible module system that allows organizing code into independent modules
• Dependency Injection: Powerful IoC Container with Castle Windsor
• Plugin Architecture: Plugin support for extending applications

📊 Domain Driven Design (DDD)

• Entities & Value Objects: Full support for DDD patterns
• Domain Services: Managing complex business logic
• Repositories: Repository pattern for data access
• Unit of Work: Managing transactions and consistency

🔧 Utilities & Helpers

• Event Bus: Event system for loose coupling
• Caching: Multi-level caching with Memory Cache
• Auditing: Automatic auditing of data changes
• Localization: Multi-language support
• Background Jobs: Background task processing
• Real-time: SignalR support for real-time communication

🛡️ Security & Authorization

• Permission System: Flexible permission system
• Multi-tenancy: Multi-tenant architecture support
• Session Management: User session management

📦 Installation

Package Manager Console

Install-Package Lms

.NET CLI

dotnet add package Lms

PackageReference

<PackageReference Include="Lms" Version="10.4.0" />

🏁 Quick Start

1. Create Startup Module

using Lms.Modules;
using Lms.Dependency;

[DependsOn(typeof(LmsKernelModule))]
public class MyAppModule : LmsModule
{
    public override void PreInitialize()
    {
        // Configuration before initialization
    }

    public override void Initialize()
    {
        // Register dependencies
        IocManager.RegisterAssemblyByConvention(typeof(MyAppModule).Assembly);
    }

    public override void PostInitialize()
    {
        // Configuration after initialization
    }
}

2. Initialize Framework

using Lms;

public class Program
{
    public static void Main(string[] args)
    {
        // Initialize LMS Framework
        using (var bootstrapper = LmsBootstrapper.Create<MyAppModule>())
        {
            bootstrapper.Initialize();
            
            // Your application runs here
            Console.WriteLine("LMS Framework has been initialized!");
            
            Console.ReadLine();
        }
    }
}

3. Using Dependency Injection

public interface IMyService
{
    string GetMessage();
}

public class MyService : IMyService, ITransientDependency
{
    public string GetMessage()
    {
        return "Hello from LMS Framework!";
    }
}

// Using service
public class MyController
{
    private readonly IMyService _myService;
    
    public MyController(IMyService myService)
    {
        _myService = myService;
    }
    
    public string Get()
    {
        return _myService.GetMessage();
    }
}

🔧 Advanced Configuration

Event Bus

// Define event
public class OrderCreatedEventData : EventData
{
    public string OrderId { get; set; }
    public decimal Amount { get; set; }
}

// Event handler
public class OrderCreatedEventHandler : IEventHandler<OrderCreatedEventData>
{
    public void HandleEvent(OrderCreatedEventData eventData)
    {
        // Handle when new order is created
        Console.WriteLine($"Order {eventData.OrderId} created with amount {eventData.Amount}");
    }
}

// Trigger event
public class OrderService
{
    private readonly IEventBus _eventBus;
    
    public OrderService(IEventBus eventBus)
    {
        _eventBus = eventBus;
    }
    
    public void CreateOrder(string orderId, decimal amount)
    {
        // Create order logic...
        
        // Trigger event
        _eventBus.Trigger(new OrderCreatedEventData
        {
            OrderId = orderId,
            Amount = amount
        });
    }
}

Caching

public class ProductService
{
    private readonly ICacheManager _cacheManager;
    
    public ProductService(ICacheManager cacheManager)
    {
        _cacheManager = cacheManager;
    }
    
    public async Task<Product> GetProductAsync(int id)
    {
        return await _cacheManager
            .GetCache("ProductCache")
            .GetAsync(id.ToString(), async () => 
            {
                // Load from database if not in cache
                return await LoadProductFromDatabaseAsync(id);
            });
    }
}

Unit of Work

public class OrderService
{
    private readonly IRepository<Order> _orderRepository;
    private readonly IUnitOfWorkManager _unitOfWorkManager;
    
    public OrderService(
        IRepository<Order> orderRepository,
        IUnitOfWorkManager unitOfWorkManager)
    {
        _orderRepository = orderRepository;
        _unitOfWorkManager = unitOfWorkManager;
    }
    
    [UnitOfWork]
    public virtual async Task CreateOrderAsync(CreateOrderInput input)
    {
        var order = new Order
        {
            CustomerName = input.CustomerName,
            Amount = input.Amount
        };
        
        await _orderRepository.InsertAsync(order);
        
        // Transaction will automatically commit when method ends
    }
}

📚 Documentation and Examples

Important Directory Structure

src/Lms/
├── Application/          # Application layer components
│   ├── Features/         # Feature management
│   ├── Navigation/       # Navigation system
│   └── Services/         # Application services
├── Authorization/        # Authorization system
├── Auditing/            # Auditing functionality
├── BackgroundJobs/      # Background job processing
├── Caching/             # Caching infrastructure
├── Configuration/       # Configuration management
├── Dependency/          # Dependency injection
├── Domain/              # Domain layer
│   ├── Entities/        # Domain entities
│   ├── Repositories/    # Repository interfaces
│   └── Services/        # Domain services
├── Events/              # Event bus system
├── Localization/        # Multi-language support
├── Modules/             # Module system
├── MultiTenancy/        # Multi-tenant support
├── Notifications/       # Notification system
├── RealTime/           # Real-time communication
├── Runtime/            # Runtime services
│   ├── Caching/        # Cache implementations
│   ├── Session/        # Session management
│   └── Validation/     # Validation framework
└── Threading/          # Threading utilities

Important Interfaces

• ILmsModule: Base interface for all modules
• ITransientDependency: Marks service with Transient lifecycle
• ISingletonDependency: Marks service with Singleton lifecycle
• IRepository<T>: Generic repository interface
• IEventHandler<T>: Interface for event handlers
• IApplicationService: Base interface for application services

🔗 Related Packages

• Lms.AspNetCore: ASP.NET Core integration
• Lms.EntityFramework: Entity Framework integration
• Lms.EntityFrameworkCore: Entity Framework Core integration
• Lms.AutoMapper: AutoMapper integration
• Lms.RedisCache: Redis caching support
• Lms.HangFire: Hangfire background jobs
• Lms.MailKit: Email sending with MailKit
• Lms.Zero: Identity and tenant management

🤝 Contributing

We welcome all contributions! Please:

1. Fork repository
2. Create feature branch (git checkout -b feature/AmazingFeature)
3. Commit changes (git commit -m 'Add some AmazingFeature')
4. Push to branch (git push origin feature/AmazingFeature)
5. Create Pull Request

📄 License

This project is distributed under MIT License. See LICENSE.md file for more details.

🆘 Support

• Documentation: LMS Framework Docs
• GitHub Issues: Report bugs
• Stack Overflow: Tag lms-framework

📊 Statistics

• Target Framework: .NET 9.0
• Dependencies: Castle.Core, Newtonsoft.Json, System.Text.Json
• Package Size: ~2MB
• First Release: 2013
• Latest Version: 10.4.0

LMS Framework - Build powerful and scalable web applications! 🚀