Alis.Core.Aspect.Memory 0.8.2

Develop the video games of your dreams 💯 free!! on Windows, MacOS, Linux, Android(soon), IOS(soon).

📚 Alis.Core.Aspect.Memory

• Modular Design
• Description
• Getting Started
• License
• Contributor Guide
• Authors
• Collaborators

⚙️ Modular Design

All modules within the Alis framework, including Alis.Core.Aspect.Memory, are fully independent and can be used separately. While the primary focus of Alis is game development, these modules are designed to be versatile and can be integrated into other types of applications or environments where memory management or data validation is required.

🖥️ Platform Compatibility

The Alis framework, including Alis.Core.Aspect.Memory, is designed to support a wide range of platforms, ensuring flexibility and adaptability for developers. Each module is optimized for seamless integration across the following architectures and operating systems:

Supported Platforms:

• Windows
  • win-x64
  • win-x86
  • win-arm64
• Linux
  • linux-x64
  • linux-musl-x64
  • linux-arm
  • linux-arm64
  • linux-musl-arm
  • linux-musl-arm64
• macOS
  • osx-x64
  • osx-arm64

📖 Description

Alis.Core.Aspect.Memory is a module within the Alis framework that provides tools for memory management and validation, ensuring that values meet specified constraints. It includes a set of attributes and a validation system to ensure that data values adhere to important rules, such as non-zero or non-null values.

Features:

• Data Validation: Use attributes like [IsNotZero] and `` to ensure values meet specific conditions.
• Flexible Validation: Validator system that checks values before they are used, preventing runtime errors.
• Main Classes:
  • Validator: Validates data according to rules such as non-zero or non-null.
  • NotZeroException: Thrown when a value is zero when it shouldn't be.

🚀 Getting Started

To start using Alis.Core.Aspect.Memory, simply install the package:

dotnet add package Alis.Core.Aspect.Memory

This module is ideal for applications where data integrity is crucial, and you need to ensure that certain values adhere to specific constraints.

Basic Usage Example:

using Alis.Core.Aspect.Memory;
using System;

public static class Program
{
    /// <summary>
    ///     Gets or sets the value of the non zero value
    /// </summary>
    [IsNotZero] private static int _nonZeroValue;

    /// <summary>
    ///     Gets or sets the value of the non zero value
    /// </summary>
    private static int _nonZeroValuev2;

    /// <summary>
    ///     Gets or sets the value of the sample
    /// </summary>
    [IsNotZero]
    private static int Sample { get; set; }

    /// <summary>
    ///     Samples the method using the specified value
    /// </summary>
    /// <param name="value">The value</param>
    public static void SampleMethod([IsNotZero] int value)
    {
        
       Logger.Info("The value of value is " + value);
    }

    /// <summary>
    ///     Main the args
    /// </summary>
    /// <param name="args">The args</param>
    public static void Main(string[] args)
    {
        try
        {
            Sample = 0;
            
        }
        catch (NotZeroException e)
        {
           Logger.Info(e);
        }

        try
        {
            SampleMethod(0);
        }
        catch (NotZeroException e)
        {
           Logger.Info(e);
        }

        _nonZeroValuev2 = 0;
        

        try
        {
            _nonZeroValue = 0;
            
        }
        catch (NotZeroException ex)
        {
           Logger.Info(ex);
        }

        try
        {
            _nonZeroValue = 5;
            
           Logger.Info("NonZeroValue has been successfully set to " + _nonZeroValue);
        }
        catch (NotZeroException ex)
        {
           Logger.Info(ex.Message);
        }
    }
}

🛡️ License

The ALIS framework is released under the GNU General Public License v3 (GPL-3.0), ensuring your freedom to use, modify, and distribute the framework.

Key License Points

• Complete Freedom for Developers:
  Any software created with the ALIS framework is free to use, modify, and distribute.

• Source Code Availability:
  If you modify the ALIS framework, you must make the source code publicly available under the GPL-3.0 license.

• Monetization:
  You are free to monetize any project developed using ALIS without any royalties.

Contributor Guide

We welcome contributions to the project! Please check our Code of Conduct for guidelines on how to contribute respectfully.

Authors

Pablo Perdomo Falcón

Collaborators

Raúl Lozano Ponce	Juan Ángel Trujillo Jiménez	Pablo Perdomo Falcón	Christian García	RicardoVillarta

Gabriel	Pedro D.GR	Claudia2000pf	Carlos	Roser Almenar