MvvmCross/MvvmCross

Features

• Cross-Platform App Development - Facilitates building cross-platform applications using a shared .NET codebase that separates business logic from native UIs.
• Cross-Platform Logic Sharing - Centralizes application behavior in a single codebase to ensure consistent functionality across different operating systems.
• .NET Implementations - Functions as a comprehensive .NET MVVM framework for building cross-platform applications.
• Android Platform Integrations - Provides compatible base classes for Android activities and fragments to ensure native UI works with shared view models.
• Cross-Platform Navigation Libraries - Provides a shared API for managing type-safe routing and screen transitions across different platform targets.
• Mobile Screen Navigation - Moves the display between different views and logic states to control the user flow across platforms.
• Platform-Specific Implementations - Provides code paths and logic tailored to specific operating systems to utilize native controls and layouts.
• Hardware Abstraction Interfaces - Implements a hardware abstraction layer to provide a consistent interface for device features like cameras and sensors.
• iOS Delegate Hooks - Coordinates application startup and scene transitions using iOS delegate hooks for window setup.
• UI Data Binding - Provides a core UI data binding system that synchronizes interface elements with underlying data models using observer patterns.
• Cross-Platform Abstractions - Provides shared interfaces in a core library with platform-specific implementations for different operating systems.
• Dependency Injection Containers - Provides a centralized container to resolve required services into constructors and properties to decouple components.
• Hardware Abstraction Layers - Defines a consistent hardware abstraction layer for accessing GPS, cameras, and sensors across platforms.
• Headless Logic Decoupling - Separates business logic and state management into view models, decoupling them from visual rendering layers.
• Constructor-Based Injections - Resolves and provides required dependencies to classes during instantiation using reflection-based constructor injection.
• Dependency Injection Population - Populates interface properties with registered service implementations immediately after object construction using reflection.
• MVVM Architectures - Implements the Model-View-ViewModel architectural pattern to decouple business logic from native user interfaces.
• View-ViewModel Mapping - Links UI views to logic controllers by matching class names or using explicit attributes.
• Type-Safe State Transitions - Transitions application state between logic controllers using type-safe asynchronous commands.
• Business Logic Encapsulations - Encapsulates business rules and state in shared libraries to be reused across multiple platform projects.
• Logic-to-View Mapping - Automatically locates and displays the corresponding native view when navigating between logic controllers.
• Lifecycle-Aware ViewModels - Controls the creation and disposal of business logic objects as users navigate through the application.
• View-ViewModel Linking - Automates the connection between UI components and logic classes using generic parameters or matching root names.
• ViewModel Integration - Links views to logic controllers through base classes that automate the setup of the presentation model.
• View-ViewModel Mapping - Allows developers to override default naming conventions for view-logic pairs using explicit attributes or type specifications.
• One-Way Data Bindings - Implements one-way and two-way data flow patterns between logic controllers and UI elements.
• Data Binding - Synchronizes state between business logic data sources and interface components to ensure the UI reflects current data.
• Two-Way - Provides automatic synchronization of data between the UI and the application logic model in both directions.
• Event-to-Command Bindings - Connects UI interactions, such as button clicks, to logic commands to trigger business rules.
• Logic-to-UI Bindings - Provides the fundamental mechanism for linking user interface elements to shared business logic via field and method bindings.
• Property-Change Bindings - Synchronizes UI elements with logic properties using reflection and property change notifications.
• Native Interface Construction - Enables the construction of user interfaces using native operating system technologies to ensure platform-consistent looks.
• Platform-Mapped Components - Provides wrappers that map a single interface to platform-specific optimized UI components at runtime.
• Property Bindings - Provides a mechanism to define how logic properties map to view properties to synchronize state.
• UI Value Converters - Transforms data from logic controllers into a format specifically suitable for the native view.
• View Presentation Orchestration - Transforms logic requests into specific views using attributes to define modal or stack behavior.
• Navigation State Transfers - Provides mechanisms for passing data objects between logic controllers to initialize target page states during navigation.
• Type-Safe ViewModel Navigation - Transitions application state between logic controllers using type-safe asynchronous commands without referencing UI views.
• Data-Driven Layout Repetition - Renders a specific visual layout multiple times based on a collection of data items.
• Internationalization and Localization - Converts resource files and localized strings into platform-specific formats for internationalization.
• Application Content Localization - Loads translated strings and resources based on the user's locale for multi-language support.
• Reflection-Based Dependency Resolution - Implements dependency resolution by using runtime type analysis to match requests with providers in the IoC container.
• Converter Registration - Maps converter names to classes via assembly scanning to automate data transformation during binding.
• Application Startup Configurations - Defines the initial view and logic model to display upon launch and configures global services.
• ViewModel State Persistence - Saves and restores logic data to handle low-memory situations and native view destruction.
• Modular Library Extensions - Creates modular libraries that automatically register services and initialize dependencies during the application startup sequence.
• REST API Integrations - Sends HTTP requests and receives JSON or stream responses for communicating with remote RESTful services.
• Service Provider Swapping - Allows replacing the default inversion of control provider with a custom implementation via a service provider adapter.
• Platform Implementation Bundling - Bundles shared interfaces with platform-specific implementations into reusable packages to facilitate cross-platform dependency injection.
• Launch Sequence Checks - Executes custom checks during the launch sequence to determine the starting state or view.
• GPS Location Tracking - Retrieves geographic coordinates via GPS or network providers with configurable accuracy and power settings.
• Hardware Sensor APIs - Provides a shared code interface for interacting with various hardware sensors and geolocation APIs.
• iOS UI Layout - Provides programmatic UI layout capabilities specifically tailored for iOS platforms.
• Native View Embedding - Coordinates transitions between native platform views and cross-platform views using unified logic.
• Localization Resource Loaders - Retrieves translated strings from RESX resource files to support multi-locale internationalization.
• Framework Service Bootstrapping - Initializes the dependency injection container, data-binding engine, and navigation system during startup.
• Assembly Scanning and Discovery - Automatically discovers and registers classes for dependency injection by scanning metadata and naming patterns.
• Assembly Scanning Registrations - Automatically discovers and registers classes for dependency injection by scanning assemblies for matching naming patterns or attributes.
• Asynchronous Data Loading - Executes heavy data loading operations asynchronously after navigation to maintain user interface responsiveness.
• Navigation Interception Hooks - Executes custom logic by hooking into lifecycle events that occur before or after navigation.
• ViewModel Locator Implementations - Replaces the default instantiation sequence of logic controllers with a custom locator implementation.
• Custom IoC Adapters - Integrates external dependency injection libraries by implementing a custom adapter layer for the framework's IoC system.
• IoC Container Initialization - Bootstraps the inversion of control container and core plugins during the application startup process.
• Event Aggregators - Implements a pub-sub messaging system using weak references to facilitate communication between decoupled components.
• Open Generic Registrations - Maps open-generic interfaces to implementations to allow specific type parameters to be resolved at runtime.
• Dynamic Presentation Determination - Determines the presentation style of views at runtime based on logic requests or metadata attributes.
• Custom Presenter Behaviors - Provides mechanisms to customize the view presentation process by defining new attributes and overriding presenter behavior.
• Presentation Change Signaling - Sends hints from core logic to the interface layer to trigger view closures or history modifications.
• Service Locators - Provides a centralized mechanism to retrieve registered service implementations at runtime to decouple components.
• Bootstrapping Sequences - Provides mechanisms to override setup methods and customize the ordered execution of modules during startup.
• UI Navigation Coordination - Coordinates transitions and logical flows between different user interface screens to support patterns like master-detail and navigation drawers.
• ViewModel Discovery - Enables the framework to locate views and logic controllers across multiple projects and assemblies.
• ViewModel Result Contracts - Enables passing data back from a child logic controller to a parent using a defined contract.
• Weak Reference Messaging - Implements a pub-sub messaging system using weak references to facilitate decoupled communication without causing memory leaks.
• Network Connectivity Monitoring - Tracks real-time network connectivity status to determine if the device is online or offline.
• Alternative Navigation Patterns - Replaces full-screen navigation with alternative patterns such as tabbed displays and split-views.
• Attribute-Driven Presentation - Determines whether a view is displayed as a modal, stack, or root by evaluating metadata attributes at runtime.
• Binding Value Converters - Implements a reflection-based system to index and resolve value converters used within UI binding expressions.
• Modal Presentations - Manages the presentation of views as modal overlays, sheets, or window content.
• Conditional Element Visibility - Converts boolean or string properties into platform-specific visibility values to dynamically show or hide UI elements.
• Manual Binding Factories - Allows registration of manual target factories to link UI properties when default reflection conventions fail.
• Decoupled Interaction Requests - Triggers interface actions from the logic layer using a decoupled messaging mechanism.
• Dynamic Navigation Routing - Determines which logic controller to display based on URI parameters or runtime conditions.
• RecyclerView Item Click Dispatchers - Dispatches specific callbacks for tap and long-press events on individual list items to trigger logic commands.
• Infinite Scrolling - Implements UI patterns that automatically load additional content as the user reaches the bottom of a list.
• Master-Detail Layouts - Implements adaptive interface patterns that switch between navigation stacks and split-views based on screen size.
• Method Callback Binding - Binds user interface events directly to logic methods to bypass the need for command properties.
• Extensible Presentation Attributes - Allows the definition of custom view presentation behaviors through the registration of new attributes.
• Three-Panel Layouts - Supports responsive interface designs that organize content into three distinct functional columns.
• Sidebars - Provides layout components for managing the behavior and visibility of drawer-style navigation sidebars.
• Scoped Dependency Injection - Provides nested dependency containers to allow isolated state instances within specific application scopes.
• System Dialogs - Triggers native OS-level alerts, notifications, and user input prompts from shared logic.
• Data-Driven Table Views - Maps data collections to table views using standard cells and custom layouts.
• Deeplinking Navigation Stacks - Maps specific URIs to logic controllers to build navigation stacks and support external links.
• Controller Presentation - Determines the presentation of view controllers based on dynamic request parameters within the UI layout system.
• View Recycling Systems - Implements view recycling systems to optimize memory and performance when binding data collections to list widgets.
• View Transitions - Coordinates transitions between native and cross-platform views using presenters to maintain state.
• Multi-Window Controllers - Provides APIs for managing multiple independent window instances and associating them with logic models.
• Loading State Indicators - Binds the execution state of asynchronous operations to the UI to display loading indicators.
• JSON-Based Localization Systems - Supports multi-language applications by loading translation text from external JSON files.
• Desktop and Mobile Apps - MVVM framework for cross-platform .NET solutions.
• Developer Utilities - Framework for implementing the MVVM pattern in cross-platform apps.
• Dotnet Projects - Listed in the “Dotnet Projects” section of the Awesome For Beginners awesome list.
• MVVM Frameworks - Comprehensive cross-platform mobile development framework.

Star history