• Webinars
  • Docs
  • Download
  • Blogs
  • Contact Us
Show / Hide Table of Contents
  • Programmer's Guide
  • Client Side API Programming
    • Setting Up Development Environment
    • Basic Cache Operations
      • Initialize Cache
      • Add Data to Cache
      • Update Data in Cache
      • Fetch Data From Cache
      • Remove Data From Cache
      • Dispose Cache
    • Bulk Operations
      • Adding Collection to Cache
      • Updating Collection in Cache
      • Retrieving Collection from Cache
      • Removing Collection from Cache
      • Deleting Collection from Cache
    • Asynchronous Operations
      • Using Asynchronous Operations
      • Using Asynchronous Operations with Callback Methods
    • Groups and Subgroups
      • Adding/Updating Data Group in Cache
      • Retrieving Data Group from Cache
      • Removing Data Group from Cache
    • Tagging Data in NCache
      • Creating Tags
      • Adding Items with Tags
      • Retrieving Previously Tagged Data
      • Removing Tagged Items from Cache
    • Named Tags
    • Data Expiration Strategies
      • Using Absolute Expiration
      • Using Sliding Expiration
    • Cache Dependencies
      • Key Dependency
      • File Dependency
      • Notification based Dependencies
        • Database Dependency using SQL Server
        • Database Dependency using Oracle
      • Polling Based Dependency
      • Custom Data Source Dependency
      • Multiple Cache Sync Dependency
      • Aggregate Dependency
      • Add Dependency to Existing Item
      • Using CLR Procedures to Call NCache
    • Locking Data in NCache
      • Locking Items in Cache (Pessimistic Locking)
      • Locking Items with Cache Item Versioning (Optimistic Locking)
    • SQL Reference for NCache
      • SQL Syntax
      • Querying Samples for Operators
      • Querying Data in NCache
      • NCache Language Integrated Query (LINQ)
        • Using LINQ in NCache
        • Configuring LINQPad for NCache
        • Querying NCache Data in LINQPad
    • Event Notifications
      • Cache Level Event Notifications
      • Item Level Event Notifications
      • Custom Event Notifications
    • Publish/Subscribe (Pub/Sub) in NCache
      • Pub/Sub Topics
      • Managing Topics
      • Pub/Sub Messages
        • Message Behavior and Properties
        • Creating a Message
      • Publish Messages to Topic
      • Subscribe for Topic Messages
      • Monitoring Pub/Sub Topics
    • Continuous Query
    • Using Streams in NCache
      • Opening with Stream Modes
      • Adding and Updating Data with Streams
      • Retrieving Data from Streams
      • Closing a Stream
    • Security and Encryption
      • NCache Security
      • NCache Data Encryption
    • Data Compression
    • NCache Management API
  • Server Side API Programming
    • Cache Startup Loader
      • Components of Cache Startup Loader
      • Sample Implementation of ICacheLoader on Single Node
      • Sample Implementation of ICacheLoader with Distribution Hints
    • Data Source Providers (Backing Source)
      • Read-Through Caching
        • Configure Read-Through Provider
        • Using Read-Through with Cache Operations
      • Write-Through Caching
        • Configuring Write-Through Provider
        • Using Write-Through with Basic Operations
        • Using Write-Behind with Basic Operations
        • Using Write-Behind with Bulk Operations
        • Using Write-Behind with Async Operations
        • Monitor Write-Through Counters
    • Custom Dependency
      • Sample Implementation of Custom Dependency
      • Sample Usage of Custom Dependency
    • WAN Replication through Bridge
      • Bridge Configurations
      • Implementing Bridge Conflict Resolver
    • Entry Processor
      • Sample Implementation of IEntryProcessor Interface
      • Sample Usage of EntryProcessor
    • MapReduce
      • Sample Implementation of MapReduce Interfaces
      • Sample Usage of MapReduce
    • Aggregator
      • Sample Implementation of IValueExtractor Interface
      • Sample Implementation of IAggregator Interface
      • Sample Usage of Aggregator
    • Dynamic Compact Serialization
  • Client Side ASP.NET Features
    • ASP.NET
      • ASP.NET Session State Provider for NCache
      • Multi-Region ASP.NET Session State Provider for NCache
    • ASP.NET Core
      • Session Storage in ASP.NET Core
        • Configure NCache ASP.NET Core Session Provider
        • Configure ASP.NET Core Sessions with NCache IDistributedCache Provider
      • Multi-Region ASP.NET Core Session Provider for NCache
      • Object Caching in ASP.NET Core
    • ASP.NET SignalR
      • Using NCache Extension for SignalR
    • View State Caching
      • Configuring and Using Content Optimization
      • Group View State with Sessions
      • Limit View State Caching
      • Perform Page Level Grouping for View State
    • ASP.NET Output Cache
      • Configure ASP.NET Output Caching
      • Using ASP.NET Output Cache with Custom Hooks
  • Client Side Third Party Integrations
    • Migrating AppFabric to NCache
      • AppFabric API vs. NCache API
    • NHibernate
      • NCache as NHibernate Second Level Cache
      • Using NHibernate Query Caching
      • Configuring Database Synchronization with NHibernate
    • Entity Framework Caching Integration
      • NCache as Entity Framework Second Level Cache
      • Entity Framework Caching Config File
    • Entity Framework Core Caching
      • Installing NCache Entity Framework Core Provider
      • Configuring NCache Entity Framework Core Provider
      • Using NCache Entity Framework Core Provider
        • Caching Options for EF Core Provider
        • LINQ APIs for EF Core Provider
        • Cache Only APIs for EF Core Provider
        • Query Deferred APIs for EF Core Provider
      • Logging in NCache Entity Framework Core Provider
    • Memcached
      • NCache Memcached Gateway Approach
      • Memcached Client Plugin for .NET
    • Debug NCache Providers in Visual Studio
    • NCache for Visual Studio Extension

Sample Implementation of MapReduce Interfaces

MapReduce related interfaces are provided in Alachisoft.NCache.Runtime.Mapreduce namespace.

Users can implement the following interfaces:

Mapper

Implement the interface IMapper and provide implementation for Map() method.

Member Description
Map() This method will contain the logic to map the input from cache into more meaningful and goal specific key-value pairs which can be sent to the Reducer or optional Combiner. Referring to the workflow diagram, the string input is transformed by emitting each word with a key-value pair like <word, count> in the Mapper.
public class WordCountMapper : IMapper
{
    string[] parsedline;
    string line;

    public void Map(Object key, Object value, IOutputMap outputMap)
    {
        line = value.ToString();
        parsedline = line.Split(' ');
        for (int i = 0; i < parsedline.Length; i++)
        {
            outputMap.Emit(parsedline[i], 1);
        }
    }

    public void Dispose()
    {
        //dispose resources
    }
}

Combiner Factory

Implement the interface ICombinerFactory and provide implementation for its Create(key) method. Providing Combiner Factory or Combiner is optional.

Member Description
Create(key) This method will provide the incoming element with a new instance of the Combiner so that it merges the intermediate key-value pairs from the Mapper.
public class WordCountCombinerFactory : ICombinerFactory
{
    public ICombiner Create(object key)
    {
        WordCountCombiner wcCombiner = new WordCountCombiner();
        return wcCombiner;
    }
}

Combiner

Implement the interface ICombiner and provide implementation for the methods:

Member Description
BeginCombine() This method will provide the user with a starting point to initialize any parameters you want to be used before the actual combining of elements begins.
Combine() This method reduces the task result locally in chunks so that the Reducer is not burdened with excessive processing. If the workflow diagram is referred, it means that the elements with the same keys are grouped together before being sent to the Reducer for counting the word occurrence.
FinishChunk() This method marks the end of the Combiner functionality as when the number of combined results reaches the specified chunk size, it sends the tasks in the form of a chunk to the Reducer and resets its internal state for the next chunk.
public class WordCountCombiner : ICombiner
{
    int count = 0;

    public void BeginCombine()
    {
        //any initialization
    }

    public void Combine(object value)
    {
        count += int.Parse(value.ToString());
    }

    public object FinishChunk()
    {
        return count;
    }

    public void Dispose()
    {
        //dispose resources
    }
}

Reducer Factory

Implement the interface IReducerFactory and provide implementation for its Create(key)method. Providing Reducer Factory or Reducer is optional.

Member Description
Create(key) This method will provide the incoming element with a new instance of the Reducer so that it merges the intermediate key-value pairs from the Combiner.
public class WordCountReducerFactory : IReducerFactory
{
    public IReducer Create(object key)
    {
        WordCountReducer wcReducer = new WordCountReducer(key);
        return wcReducer;
    }  

}

Reducer

Implement the interface IReducer and provide implementation for the methods:

Member Description
BeginReduce() This method will provide the user with a starting point to initialize any parameters you want to be used before the actual reducing of elements begins.
Reduce() This method will reduce (process) the intermediate key-value pairs into further meaningful pairs. If the workflow diagram is referred, it means that the values of the grouped elements from Combiner are summed up to find the actual word count.
FinishReduce() This method will provide the task with the final result of the map reduce operation for specific intermediate key/value pair.
public class WordCountReducer : IReducer
{
    int count = 0;
    object reducerKey;

    public WordCountReducer(object key)
    {
        reducerKey = key;
    }

    public void BeginReduce()
    {
        //perform operations
    }

    public void Reduce(object value)
    {
        count += int.Parse(value.ToString());
    }

    public KeyValuePair FinishReduce()
    {
        KeyValuePair kvp = new KeyValuePair();
        kvp.Key = reducerKey;
        kvp.Value = count;
        return kvp;
    }

    public void Dispose()
    {
        //dispose resources
    }
}

Key Filter

Implement the interface IKeyFilter to provide implementation for the FilterKey() method. Providing this interface is optional.

Member Description
FilterKey(key) This method will allow user to filter the input for Mapper by specifying the keys to be processed. If this option is not utilized, the whole cache data will be taken as input for the MapReduce tasks.
public class WordCountKeyFilter : IKeyFilter
{
    public bool FilterKey(object key)
    {
        try
        {
            if (key.ToString().Contains("hungry"))
            {
                return true;
            }
        }
        catch (Exception exp)
        {
            //handle exception
        }
        return false;
    }
}

Task Tracker

You do not need to implement this interface.

The ITrackableTask interface implements the following members, which can be used if you want to track the execution of your task:

Member Description
event MapReduceCallback OnMapReduceComplete Users can register a callback on the MapReduce task that is called when task execution is completed, failed or cancelled with a parameter response that encapsulates status of the task and result (if completed).
GetResult() This is a blocking call that waits for the callback from the server about the task’s completion, failure or cancellation in the form of an ITaskResult. The ITaskResult lets you get the following:
GetResult(timeout) If no result is obtained within the specified timeout duration, OperationFailedException is thrown.
TaskId This is a GUID identification ID of the task to mark it as unique.
TaskStatus() Gets the task’s status and contains following values: Waiting, InProgress, Completed, Cancelled, Failed
CancelTask() To cancel the already running task.
  • GetEnumerator: obtain the result in the form of a dictionary

  • Status: will return either failure, success, cancelled.

  • TaskFailureReason: the reason behind the failure of the task.

Note that TaskCallback() and GetResult() cannot be executed together because GetResult is a blocking call and this combination will throw an exception.

Important

Make sure to deploy the MapReduce task libraries after implementing the interfaces using NCache Manager as guided in Configuring MapReduce in Administrators' Guide.

Back to top Copyright © 2017 Alachisoft