ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [33/37] ignite git commit: IGNITE-1348: Moved GridGain's .Net module to Ignite.
Date Fri, 04 Sep 2015 13:32:05 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IDataStreamer.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IDataStreamer.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IDataStreamer.cs
new file mode 100644
index 0000000..2713040
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IDataStreamer.cs
@@ -0,0 +1,206 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Datastream
+{
+    using System;
+    using System.Collections.Generic;
+    using Apache.Ignite.Core.Cache.Store;
+    using Apache.Ignite.Core.Common;
+
+    /// <summary>
+    /// Data streamer is responsible for loading external data into cache. It achieves it by
+    /// properly buffering updates and properly mapping keys to nodes responsible for the data
+    /// to make sure that there is the least amount of data movement possible and optimal
+    /// network and memory utilization.
+    /// <para />
+    /// Note that streamer will load data concurrently by multiple internal threads, so the
+    /// data may get to remote nodes in different order from which it was added to
+    /// the streamer.
+    /// <para />
+    /// Also note that <c>IDataStreamer</c> is not the only way to load data into cache.
+    /// Alternatively you can use 
+    /// <see cref="ICacheStore.LoadCache(Action{object, object}, object[])"/>
+    /// method to load data from underlying data store. You can also use standard cache
+    /// <c>put</c> and <c>putAll</c> operations as well, but they most likely will not perform 
+    /// as well as this class for loading data. And finally, data can be loaded from underlying 
+    /// data store on demand, whenever it is accessed - for this no explicit data loading step 
+    /// is needed.
+    /// <para />
+    /// <c>IDataStreamer</c> supports the following configuration properties:
+    /// <list type="bullet">
+    ///     <item>
+    ///         <term>PerNodeBufferSize</term>
+    ///         <description>When entries are added to data streamer they are not sent to Ignite 
+    ///         right away and are buffered internally for better performance and network utilization. 
+    ///         This setting controls the size of internal per-node buffer before buffered data is sent to 
+    ///         remote node. Default value is 1024.</description>
+    ///     </item>
+    ///     <item>
+    ///         <term>PerNodeParallelOperations</term>
+    ///         <description>Sometimes data may be added to the data streamer faster than it can be put 
+    ///         in cache. In this case, new buffered load messages are sent to remote nodes before 
+    ///         responses from previous ones are received. This could cause unlimited heap memory 
+    ///         utilization growth on local and remote nodes. To control memory utilization, this 
+    ///         setting limits maximum allowed number of parallel buffered load messages that are 
+    ///         being processed on remote nodes. If this number is exceeded, then data streamer add/remove
+    ///         methods will block to control memory utilization. Default value is 16.</description>
+    ///     </item>
+    ///     <item>
+    ///         <term>AutoFlushFrequency</term>
+    ///         <description>Automatic flush frequency in milliseconds. Essentially, this is the time 
+    ///         after which the streamer will make an attempt to submit all data added so far to remote 
+    ///         nodes. Note that there is no guarantee that data will be delivered after this concrete 
+    ///         attempt (e.g., it can fail when topology is changing), but it won't be lost anyway. 
+    ///         Disabled by default (default value is <c>0</c>).</description>
+    ///     </item>
+    ///     <item>
+    ///         <term>Isolated</term>
+    ///         <description>Defines if data streamer will assume that there are no other concurrent 
+    ///         updates and allow data streamer choose most optimal concurrent implementation. Default value 
+    ///         is <c>false</c>.</description>
+    ///     </item>
+    /// </list>
+    /// <para/>
+    /// All members are thread-safe and may be used concurrently from multiple threads.
+    /// </summary>
+    public interface IDataStreamer<TK, TV> : IDisposable
+    {
+        /// <summary>
+        /// Name of the cache to load data to.
+        /// </summary>
+        string CacheName { get; }
+
+        /// <summary>
+        /// Flag value indicating that this data streamer assumes that there could be concurrent updates to the cache. 
+        /// <para />
+        /// Default is <code>false</code>.
+        /// </summary>
+        bool AllowOverwrite { get; set; }
+
+        /// <summary>
+        /// Flag indicating that write-through behavior should be disabled for data loading.
+        /// <para />
+        /// Default is <code>false</code>.
+        /// </summary>
+        bool SkipStore { get; set; }
+
+        /// <summary>
+        /// Size of per node key-value pairs buffer.
+        /// <para />
+        /// Setter must be called before any add/remove operation.
+        /// <para />
+        /// Default is <code>1024</code>.
+        /// </summary>
+        int PerNodeBufferSize { get; set; }
+
+        /// <summary>
+        /// Maximum number of parallel load operations for a single node.
+        /// <para />
+        /// Setter must be called before any add/remove operation.
+        /// <para />
+        /// Default is <code>16</code>.
+        /// </summary>
+        int PerNodeParallelOperations { get; set; }
+
+        /// <summary>
+        /// Automatic flush frequency in milliseconds. Essentially, this is the time after which the
+        /// streamer will make an attempt to submit all data added so far to remote nodes.
+        /// Note that there is no guarantee that data will be delivered after this concrete
+        /// attempt (e.g., it can fail when topology is changing), but it won't be lost anyway.
+        /// <para />
+        /// If set to <code>0</code>, automatic flush is disabled.
+        /// <para />
+        /// Default is <code>0</code> (disabled).
+        /// </summary>
+        long AutoFlushFrequency { get; set; }
+
+        /// <summary>
+        /// Gets future for this loading process. This future completes whenever method
+        /// <see cref="IDataStreamer{K,V}.Close(bool)"/> completes.
+        /// </summary>
+        IFuture Future { get; }
+
+        /// <summary>
+        /// Gets or sets custom stream receiver.
+        /// </summary>
+        IStreamReceiver<TK, TV> Receiver { get; set; }
+
+        /// <summary>
+        /// Adds single key-value pair for loading. Passing <c>null</c> as value will be 
+        /// interpreted as removal.
+        /// </summary>
+        /// <param name="key">Key.</param>
+        /// <param name="val">Value.</param>
+        /// <returns>Future for this operation.</returns>
+        IFuture AddData(TK key, TV val);
+
+        /// <summary>
+        /// Adds single key-value pair for loading. Passing <c>null</c> as pair's value will 
+        /// be interpreted as removal.
+        /// </summary>
+        /// <param name="pair">Key-value pair.</param>
+        /// <returns>Future for this operation.</returns>
+        IFuture AddData(KeyValuePair<TK, TV> pair);
+
+        /// <summary>
+        /// Adds collection of key-value pairs for loading. 
+        /// </summary>
+        /// <param name="entries">Entries.</param>
+        /// <returns>Future for this operation.</returns>
+        IFuture AddData(ICollection<KeyValuePair<TK, TV>> entries);
+
+        /// <summary>
+        /// Adds key for removal.
+        /// </summary>
+        /// <param name="key">Key.</param>
+        /// <returns>Future for this operation.</returns>
+        IFuture RemoveData(TK key);
+
+        /// <summary>
+        /// Makes an attempt to load remaining data. This method is mostly similar to 
+        /// <see cref="IDataStreamer{K,V}.Flush()"/> with the difference that it won't wait and 
+        /// will exit immediately.
+        /// </summary>
+        void TryFlush();
+
+        /// <summary>
+        /// Loads any remaining data, but doesn't close the streamer. Data can be still added after
+        /// flush is finished. This method blocks and doesn't allow to add any data until all data
+        /// is loaded.
+        /// </summary>
+        void Flush();
+
+        /// <summary>
+        /// Closes this streamer optionally loading any remaining data.
+        /// </summary>
+        /// <param name="cancel">Whether to cancel ongoing loading operations. When set to <c>true</c>
+        /// there is not guarantees what data will be actually loaded to cache.</param>
+        void Close(bool cancel);
+
+        /// <summary>
+        /// Gets streamer instance with portable mode enabled, changing key and/or value types if necessary.
+        /// In portable mode stream receiver gets data in portable format.
+        /// You can only change key/value types when transitioning from non-portable to portable streamer;
+        /// Changing type of portable streamer is not allowed and will throw an <see cref="InvalidOperationException"/>
+        /// </summary>
+        /// <typeparam name="TK1">Key type in portable mode.</typeparam>
+        /// <typeparam name="TV1">Value type in protable mode.</typeparam>
+        /// <returns>Streamer instance with portable mode enabled.</returns>
+        IDataStreamer<TK1, TV1> WithKeepPortable<TK1, TV1>();
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IStreamReceiver.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IStreamReceiver.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IStreamReceiver.cs
new file mode 100644
index 0000000..d75dc54
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/IStreamReceiver.cs
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Datastream
+{
+    using System.Collections.Generic;
+    using Apache.Ignite.Core.Cache;
+
+    /// <summary>
+    /// Updates cache with batch of entries. 
+    /// Usually it is enough to configure <see cref="IDataStreamer{K,V}.AllowOverwrite" /> property and appropriate 
+    /// internal cache receiver will be chosen automatically. But in some cases custom implementation may help 
+    /// to achieve better performance.
+    /// </summary>
+    public interface IStreamReceiver<TK, TV>
+    {
+        /// <summary>
+        /// Updates cache with batch of entries.
+        /// </summary>
+        /// <param name="cache">Cache.</param>
+        /// <param name="entries">Entries.</param>
+        void Receive(ICache<TK, TV> cache, ICollection<ICacheEntry<TK, TV>> entries);
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamTransformer.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamTransformer.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamTransformer.cs
new file mode 100644
index 0000000..0398342
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamTransformer.cs
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Datastream
+{
+    using System.Collections.Generic;
+    using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Impl.Common;
+    using Apache.Ignite.Core.Impl.Datastream;
+    using Apache.Ignite.Core.Impl.Portable;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Convenience adapter to transform update existing values in streaming cache 
+    /// based on the previously cached value.
+    /// </summary>
+    /// <typeparam name="TK">Key type.</typeparam>
+    /// <typeparam name="TV">Value type.</typeparam>
+    /// <typeparam name="TA">The type of the processor argument.</typeparam>
+    /// <typeparam name="TR">The type of the processor result.</typeparam>
+    public sealed class StreamTransformer<TK, TV, TA, TR> : IStreamReceiver<TK, TV>, 
+        IPortableWriteAware
+    {
+        /** Entry processor. */
+        private readonly ICacheEntryProcessor<TK, TV, TA, TR> _proc;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StreamTransformer{K, V, A, R}"/> class.
+        /// </summary>
+        /// <param name="proc">Entry processor.</param>
+        public StreamTransformer(ICacheEntryProcessor<TK, TV, TA, TR> proc)
+        {
+            IgniteArgumentCheck.NotNull(proc, "proc");
+
+            _proc = proc;
+        }
+
+        /** <inheritdoc /> */
+        public void Receive(ICache<TK, TV> cache, ICollection<ICacheEntry<TK, TV>> entries)
+        {
+            var keys = new List<TK>(entries.Count);
+
+            foreach (var entry in entries)
+                keys.Add(entry.Key);
+
+            cache.InvokeAll(keys, _proc, default(TA));
+        }
+
+        /** <inheritdoc /> */
+        void IPortableWriteAware.WritePortable(IPortableWriter writer)
+        {
+            var w = (PortableWriterImpl)writer;
+
+            w.WriteByte(StreamReceiverHolder.RcvTransformer);
+
+            PortableUtils.WritePortableOrSerializable(w, _proc);
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamVisitor.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamVisitor.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamVisitor.cs
new file mode 100644
index 0000000..5d155d7
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Datastream/StreamVisitor.cs
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Datastream
+{
+    using System;
+    using System.Collections.Generic;
+    using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Impl.Common;
+
+    /// <summary>
+    /// Convenience adapter to visit every key-value tuple in the stream.
+    /// Note that the visitor does not update the cache.
+    /// </summary>
+    /// <typeparam name="TK">The type of the cache key.</typeparam>
+    /// <typeparam name="TV">The type of the cache value.</typeparam>
+    [Serializable]
+    public sealed class StreamVisitor<TK, TV> : IStreamReceiver<TK, TV>
+    {
+        /** Visitor action */
+        private readonly Action<ICache<TK, TV>, ICacheEntry<TK, TV>> _action;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StreamVisitor{K, V}"/> class.
+        /// </summary>
+        /// <param name="action">The action to be called on each stream entry.</param>
+        public StreamVisitor(Action<ICache<TK, TV>, ICacheEntry<TK, TV>> action)
+        {
+            IgniteArgumentCheck.NotNull(action, "action");
+
+            _action = action;
+        }
+
+        /** <inheritdoc /> */
+        public void Receive(ICache<TK, TV> cache, ICollection<ICacheEntry<TK, TV>> entries)
+        {
+            foreach (var entry in entries)
+                _action(cache, entry);
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheEvent.cs
new file mode 100644
index 0000000..ff5084b
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheEvent.cs
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Common;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// In-memory database (cache) event.
+    /// </summary>
+    public sealed class CacheEvent : EventBase
+	{
+        /** */
+        private readonly string _cacheName;
+
+        /** */
+        private readonly int _partition;
+
+        /** */
+        private readonly bool _isNear;
+
+        /** */
+        private readonly IClusterNode _eventNode;
+
+        /** */
+        private readonly object _key;
+
+        /** */
+        private readonly IgniteGuid _xid;
+
+        /** */
+        private readonly object _lockId;
+
+        /** */
+        private readonly object _newValue;
+
+        /** */
+        private readonly object _oldValue;
+
+        /** */
+        private readonly bool _hasOldValue;
+
+        /** */
+        private readonly bool _hasNewValue;
+
+        /** */
+        private readonly Guid _subjectId;
+
+        /** */
+        private readonly string _closureClassName;
+
+        /** */
+        private readonly string _taskName;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal CacheEvent(IPortableRawReader r) : base(r)
+        {
+            _cacheName = r.ReadString();
+            _partition = r.ReadInt();
+            _isNear = r.ReadBoolean();
+            _eventNode = ReadNode(r);
+            _key = r.ReadObject<object>();
+            _xid = IgniteGuid.ReadPortable(r);
+            _lockId = r.ReadObject<object>();
+            _newValue = r.ReadObject<object>();
+            _oldValue = r.ReadObject<object>();
+            _hasOldValue = r.ReadBoolean();
+            _hasNewValue = r.ReadBoolean();
+            _subjectId = r.ReadGuid() ?? Guid.Empty;
+            _closureClassName = r.ReadString();
+            _taskName = r.ReadString();
+        }
+		
+        /// <summary>
+        /// Gets cache name. 
+        /// </summary>
+        public string CacheName { get { return _cacheName; } }
+
+        /// <summary>
+        /// Gets partition for the event which is the partition the key belongs to. 
+        /// </summary>
+        public int Partition { get { return _partition; } }
+
+        /// <summary>
+        /// Gets flag indicating whether event happened on near or partitioned cache. 
+        /// </summary>
+        public bool IsNear { get { return _isNear; } }
+
+        /// <summary>
+        /// Gets node which initiated cache operation or null if that node is not available. 
+        /// </summary>
+        public IClusterNode EventNode { get { return _eventNode; } }
+
+        /// <summary>
+        /// Gets cache entry associated with event. 
+        /// </summary>
+        public object Key { get { return _key; } }
+
+        /// <summary>
+        /// ID of surrounding cache cache transaction or null if there is no surrounding transaction. 
+        /// </summary>
+        public IgniteGuid Xid { get { return _xid; } }
+
+        /// <summary>
+        /// ID of the lock if held or null if no lock held. 
+        /// </summary>
+        public object LockId { get { return _lockId; } }
+
+        /// <summary>
+        /// Gets new value for this event. 
+        /// </summary>
+        public object NewValue { get { return _newValue; } }
+
+        /// <summary>
+        /// Gets old value associated with this event. 
+        /// </summary>
+        public object OldValue { get { return _oldValue; } }
+
+        /// <summary>
+        /// Gets flag indicating whether cache entry has old value in case if we only have old value in serialized form 
+        /// in which case <see cref="OldValue" /> will return null. 
+        /// </summary>
+        public bool HasOldValue { get { return _hasOldValue; } }
+
+        /// <summary>
+        /// Gets flag indicating whether cache entry has new value in case if we only have new value in serialized form 
+        /// in which case <see cref="NewValue" /> will return null. 
+        /// </summary>
+        public bool HasNewValue { get { return _hasNewValue; } }
+
+        /// <summary>
+        /// Gets security subject ID initiated this cache event, if available. This property is available only for <see 
+        /// cref="EventType.EvtCacheObjectPut" />, <see cref="EventType.EvtCacheObjectRemoved" /> and <see 
+        /// cref="EventType.EvtCacheObjectRead" /> cache events. Subject ID will be set either to nodeId initiated 
+        /// cache update or read or client ID initiated cache update or read. 
+        /// </summary>
+        public Guid SubjectId { get { return _subjectId; } }
+
+        /// <summary>
+        /// Gets closure class name (applicable only for TRANSFORM operations). 
+        /// </summary>
+        public string ClosureClassName { get { return _closureClassName; } }
+
+        /// <summary>
+        /// Gets task name if cache event was caused by an operation initiated within task execution. 
+        /// </summary>
+        public string TaskName { get { return _taskName; } }
+        
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: IsNear={1}, Key={2}, HasNewValue={3}, HasOldValue={4}, NodeId={5}", Name, 
+                _isNear, _key, HasNewValue, HasOldValue, Node.Id);
+	    }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryExecutedEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryExecutedEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryExecutedEvent.cs
new file mode 100644
index 0000000..8443c68
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryExecutedEvent.cs
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Cache query execution event.
+    /// </summary>
+    public sealed class CacheQueryExecutedEvent : EventBase
+	{
+        /** */
+        private readonly string _queryType;
+
+        /** */
+        private readonly string _cacheName;
+
+        /** */
+        private readonly string _className;
+
+        /** */
+        private readonly string _clause;
+
+        /** */
+        private readonly Guid _subjectId;
+
+        /** */
+        private readonly string _taskName;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal CacheQueryExecutedEvent(IPortableRawReader r) : base(r)
+        {
+            _queryType = r.ReadString();
+            _cacheName = r.ReadString();
+            _className = r.ReadString();
+            _clause = r.ReadString();
+            _subjectId = r.ReadGuid() ?? Guid.Empty;
+            _taskName = r.ReadString();
+        }
+		
+        /// <summary>
+        /// Gets query type. 
+        /// </summary>
+        public string QueryType { get { return _queryType; } }
+
+        /// <summary>
+        /// Gets cache name on which query was executed. 
+        /// </summary>
+        public string CacheName { get { return _cacheName; } }
+
+        /// <summary>
+        /// Gets queried class name. Applicable for SQL and full text queries. 
+        /// </summary>
+        public string ClassName { get { return _className; } }
+
+        /// <summary>
+        /// Gets query clause. Applicable for SQL, SQL fields and full text queries. 
+        /// </summary>
+        public string Clause { get { return _clause; } }
+
+        /// <summary>
+        /// Gets security subject ID. 
+        /// </summary>
+        public Guid SubjectId { get { return _subjectId; } }
+
+        /// <summary>
+        /// Gets the name of the task that executed the query (if any). 
+        /// </summary>
+        public string TaskName { get { return _taskName; } }
+
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: QueryType={1}, CacheName={2}, ClassName={3}, Clause={4}, SubjectId={5}, " +
+	                             "TaskName={6}", Name, QueryType, CacheName, ClassName, Clause, SubjectId, TaskName);
+	    }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryReadEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryReadEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryReadEvent.cs
new file mode 100644
index 0000000..7338eab
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheQueryReadEvent.cs
@@ -0,0 +1,134 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Cache query read event.
+    /// </summary>
+    public sealed class CacheQueryReadEvent : EventBase
+	{
+        /** */
+        private readonly string _queryType;
+
+        /** */
+        private readonly string _cacheName;
+
+        /** */
+        private readonly string _className;
+
+        /** */
+        private readonly string _clause;
+
+        /** */
+        private readonly Guid _subjectId;
+
+        /** */
+        private readonly string _taskName;
+
+        /** */
+        private readonly object _key;
+
+        /** */
+        private readonly object _value;
+
+        /** */
+        private readonly object _oldValue;
+
+        /** */
+        private readonly object _row;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal CacheQueryReadEvent(IPortableRawReader r) : base(r)
+        {
+            _queryType = r.ReadString();
+            _cacheName = r.ReadString();
+            _className = r.ReadString();
+            _clause = r.ReadString();
+            _subjectId = r.ReadGuid() ?? Guid.Empty;
+            _taskName = r.ReadString();
+            _key = r.ReadObject<object>();
+            _value = r.ReadObject<object>();
+            _oldValue = r.ReadObject<object>();
+            _row = r.ReadObject<object>();
+        }
+		
+        /// <summary>
+        /// Gets query type. 
+        /// </summary>
+        public string QueryType { get { return _queryType; } }
+
+        /// <summary>
+        /// Gets cache name on which query was executed. 
+        /// </summary>
+        public string CacheName { get { return _cacheName; } }
+
+        /// <summary>
+        /// Gets queried class name. Applicable for SQL and full text queries. 
+        /// </summary>
+        public string ClassName { get { return _className; } }
+
+        /// <summary>
+        /// Gets query clause. Applicable for SQL, SQL fields and full text queries. 
+        /// </summary>
+        public string Clause { get { return _clause; } }
+
+        /// <summary>
+        /// Gets security subject ID. 
+        /// </summary>
+        public Guid SubjectId { get { return _subjectId; } }
+
+        /// <summary>
+        /// Gets the name of the task that executed the query (if any). 
+        /// </summary>
+        public string TaskName { get { return _taskName; } }
+
+        /// <summary>
+        /// Gets read entry key. 
+        /// </summary>
+        public object Key { get { return _key; } }
+
+        /// <summary>
+        /// Gets read entry value. 
+        /// </summary>
+        public object Value { get { return _value; } }
+
+        /// <summary>
+        /// Gets read entry old value (applicable for continuous queries). 
+        /// </summary>
+        public object OldValue { get { return _oldValue; } }
+
+        /// <summary>
+        /// Gets read results set row. 
+        /// </summary>
+        public object Row { get { return _row; } }
+
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: QueryType={1}, CacheName={2}, ClassName={3}, Clause={4}, SubjectId={5}, " +
+	                             "TaskName={6}, Key={7}, Value={8}, OldValue={9}, Row={10}", Name, QueryType, 
+                                 CacheName, ClassName, Clause, SubjectId, TaskName, Key, Value, OldValue, Row);
+	    }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheRebalancingEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheRebalancingEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheRebalancingEvent.cs
new file mode 100644
index 0000000..656550a
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CacheRebalancingEvent.cs
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// In-memory database (cache) rebalancing event. Rebalance event happens every time there is a change
+    /// </summary>
+    public sealed class CacheRebalancingEvent : EventBase
+	{
+        /** */
+        private readonly string _cacheName;
+
+        /** */
+        private readonly int _partition;
+
+        /** */
+        private readonly IClusterNode _discoveryNode;
+
+        /** */
+        private readonly int _discoveryEventType;
+
+        /** */
+        private readonly string _discoveryEventName;
+
+        /** */
+        private readonly long _discoveryTimestamp;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal CacheRebalancingEvent(IPortableRawReader r) : base(r)
+        {
+            _cacheName = r.ReadString();
+            _partition = r.ReadInt();
+            _discoveryNode = ReadNode(r);
+            _discoveryEventType = r.ReadInt();
+            _discoveryEventName = r.ReadString();
+            _discoveryTimestamp = r.ReadLong();
+        }
+		
+        /// <summary>
+        /// Gets cache name. 
+        /// </summary>
+        public string CacheName { get { return _cacheName; } }
+
+        /// <summary>
+        /// Gets partition for the event. 
+        /// </summary>
+        public int Partition { get { return _partition; } }
+
+        /// <summary>
+        /// Gets shadow of the node that triggered this rebalancing event. 
+        /// </summary>
+        public IClusterNode DiscoveryNode { get { return _discoveryNode; } }
+
+        /// <summary>
+        /// Gets type of discovery event that triggered this rebalancing event. 
+        /// </summary>
+        public int DiscoveryEventType { get { return _discoveryEventType; } }
+
+        /// <summary>
+        /// Gets name of discovery event that triggered this rebalancing event. 
+        /// </summary>
+        public string DiscoveryEventName { get { return _discoveryEventName; } }
+
+        /// <summary>
+        /// Gets timestamp of discovery event that caused this rebalancing event. 
+        /// </summary>
+        public long DiscoveryTimestamp { get { return _discoveryTimestamp; } }
+
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: CacheName={1}, Partition={2}, DiscoveryNode={3}, DiscoveryEventType={4}, " +
+	                             "DiscoveryEventName={5}, DiscoveryTimestamp={6}", Name, CacheName, Partition,
+	                             DiscoveryNode, DiscoveryEventType, DiscoveryEventName, DiscoveryTimestamp);
+	    }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CheckpointEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CheckpointEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CheckpointEvent.cs
new file mode 100644
index 0000000..7b7ea59
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/CheckpointEvent.cs
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Grid checkpoint event.
+    /// </summary>
+    public sealed class CheckpointEvent : EventBase
+	{
+        /** */
+        private readonly string _key;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal CheckpointEvent(IPortableRawReader r) : base(r)
+        {
+            _key = r.ReadString();
+        }
+		
+        /// <summary>
+        /// Gets checkpoint key associated with this event. 
+        /// </summary>
+        public string Key { get { return _key; } }
+
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: Key={1}", Name, Key);
+	    }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/DiscoveryEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/DiscoveryEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/DiscoveryEvent.cs
new file mode 100644
index 0000000..5b5443c
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/DiscoveryEvent.cs
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Impl;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Grid discovery event.
+    /// </summary>
+    public sealed class DiscoveryEvent : EventBase
+	{
+        /** */
+        private readonly IClusterNode _eventNode;
+
+        /** */
+        private readonly long _topologyVersion;
+
+        /** */
+        private readonly ReadOnlyCollection<IClusterNode> _topologyNodes;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        internal DiscoveryEvent(IPortableRawReader r) : base(r)
+        {
+            _eventNode = ReadNode(r);
+            _topologyVersion = r.ReadLong();
+
+            var nodes = IgniteUtils.ReadNodes(r);
+
+            _topologyNodes = nodes == null ? null : new ReadOnlyCollection<IClusterNode>(nodes);
+        }
+
+        /// <summary>
+        /// Gets node that caused this event to be generated. It is potentially different from the node on which this 
+        /// event was recorded. For example, node A locally recorded the event that a remote node B joined the topology. 
+        /// In this case this method will return ID of B. 
+        /// </summary>
+        public IClusterNode EventNode { get { return _eventNode; } }
+
+        /// <summary>
+        /// Gets topology version if this event is raised on topology change and configured discovery
+        /// SPI implementation supports topology versioning.
+        /// </summary>
+        public long TopologyVersion { get { return _topologyVersion; } }
+
+        /// <summary>
+        /// Gets topology nodes from topology snapshot. If SPI implementation does not support versioning, the best 
+        /// effort snapshot will be captured. 
+        /// </summary>
+        public ICollection<IClusterNode> TopologyNodes { get { return _topologyNodes; } }
+
+        /** <inheritDoc /> */
+	    public override string ToShortString()
+	    {
+	        return string.Format("{0}: EventNode={1}, TopologyVersion={2}, TopologyNodes={3}", Name, EventNode, 
+                TopologyVersion, TopologyNodes.Count);
+	    }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventBase.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventBase.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventBase.cs
new file mode 100644
index 0000000..2b905a1
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventBase.cs
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Common;
+    using Apache.Ignite.Core.Impl.Portable;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Base event implementation.
+    /// </summary>
+    public abstract class EventBase : IEvent, IEquatable<EventBase>
+    {
+        /** */
+        private readonly IgniteGuid _id;
+
+        /** */
+        private readonly long _localOrder;
+
+        /** */
+        private readonly IClusterNode _node;
+
+        /** */
+        private readonly string _message;
+
+        /** */
+        private readonly int _type;
+
+        /** */
+        private readonly string _name;
+
+        /** */
+        private readonly DateTime _timeStamp;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventBase"/> class.
+        /// </summary>
+        /// <param name="r">The reader to read data from.</param>
+        protected EventBase(IPortableRawReader r)
+        {
+            _id = IgniteGuid.ReadPortable(r);
+
+            _localOrder = r.ReadLong();
+
+            _node = ReadNode(r);
+
+            _message = r.ReadString();
+            _type = r.ReadInt();
+            _name = r.ReadString();
+            _timeStamp = r.ReadDate() ?? DateTime.Now;
+        }
+
+        /** <inheritDoc /> */
+        public IgniteGuid Id
+        {
+            get { return _id; }
+        }
+
+        /** <inheritDoc /> */
+        public long LocalOrder
+        {
+            get { return _localOrder; }
+        }
+
+        /** <inheritDoc /> */
+        public IClusterNode Node
+        {
+            get { return _node; }
+        }
+
+        /** <inheritDoc /> */
+        public string Message
+        {
+            get { return _message; }
+        }
+
+        /** <inheritDoc /> */
+        public int Type
+        {
+            get { return _type; }
+        }
+
+        /** <inheritDoc /> */
+        public string Name
+        {
+            get { return _name; }
+        }
+
+        /** <inheritDoc /> */
+        public DateTime TimeStamp
+        {
+            get { return _timeStamp; }
+        }
+
+        /** <inheritDoc /> */
+        public virtual string ToShortString()
+        {
+            return ToString();
+        }
+
+        /** <inheritDoc /> */
+        public bool Equals(EventBase other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            
+            return _id.Equals(other._id);
+        }
+
+        /** <inheritDoc /> */
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != GetType()) return false;
+            
+            return Equals((EventBase) obj);
+        }
+
+        /** <inheritDoc /> */
+        public override int GetHashCode()
+        {
+            return _id.GetHashCode();
+        }
+
+        /** <inheritDoc /> */
+        public override string ToString()
+        {
+            return string.Format("CacheEntry [Name={0}, Type={1}, TimeStamp={2}, Message={3}]", Name, Type, TimeStamp,
+                Message);
+        }
+
+        /// <summary>
+        /// Reads a node from stream.
+        /// </summary>
+        /// <param name="reader">Reader.</param>
+        /// <returns>Node or null.</returns>
+        protected static IClusterNode ReadNode(IPortableRawReader reader)
+        {
+            return ((PortableReaderImpl)reader).Marshaller.Ignite.GetNode(reader.ReadGuid());
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventReader.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventReader.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventReader.cs
new file mode 100644
index 0000000..aa9f538
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventReader.cs
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Portable;
+
+    /// <summary>
+    /// Event reader.
+    /// </summary>
+    internal static class EventReader
+    {
+        /// <summary>
+        /// Reads an event.
+        /// </summary>
+        /// <typeparam name="T">Type of the event</typeparam>
+        /// <param name="reader">Reader.</param>
+        /// <returns>Deserialized event.</returns>
+        /// <exception cref="System.InvalidCastException">Incompatible event type.</exception>
+        public static T Read<T>(IPortableReader reader) where T : IEvent
+        {
+            var r = reader.RawReader();
+
+            var clsId = r.ReadInt();
+
+            if (clsId == -1)
+                return default(T);
+
+            return (T) CreateInstance(clsId, r);
+        }
+
+        /// <summary>
+        /// Creates an event instance by type id.
+        /// </summary>
+        /// <param name="clsId">Type id.</param>
+        /// <param name="reader">Reader.</param>
+        /// <returns>Created and deserialized instance.</returns>
+        /// <exception cref="System.InvalidOperationException">Invalid event class id:  + clsId</exception>
+        private static IEvent CreateInstance(int clsId, IPortableRawReader reader)
+        {
+            switch (clsId)
+            {
+                case 2: return new CacheEvent(reader);
+                case 3: return new CacheQueryExecutedEvent(reader);
+                case 4: return new CacheQueryReadEvent(reader);
+                case 5: return new CacheRebalancingEvent(reader);
+                case 6: return new CheckpointEvent(reader);
+                case 7: return new DiscoveryEvent(reader);
+                case 8: return new JobEvent(reader);
+                case 9: return new SwapSpaceEvent(reader);
+                case 10: return new TaskEvent(reader);
+            }
+
+            throw new InvalidOperationException("Invalid event class id: " + clsId);
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventType.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventType.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventType.cs
new file mode 100644
index 0000000..1e649bb
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/EventType.cs
@@ -0,0 +1,514 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
+    using System.Reflection;
+
+    /// <summary>
+    /// Contains event type constants. The decision to use class and not enumeration is dictated 
+    /// by allowing users to create their own events and/or event types which would be impossible with enumerations.
+    /// <para />
+    /// Note that this interface defines not only individual type constants, 
+    /// but arrays of types as well to be conveniently used with <see cref="IEvents"/> methods.
+    /// <para />
+    /// NOTE: all types in range <b>from 1 to 1000 are reserved</b> for internal Ignite events 
+    /// and should not be used by user-defined events.
+    /// </summary>
+    public static class EventType
+    {
+        /// <summary>
+        /// Built-in event type: checkpoint was saved.
+        /// </summary>
+        public static readonly int EvtCheckpointSaved = 1;
+
+        /// <summary>
+        /// Built-in event type: checkpoint was loaded.
+        /// </summary>
+        public static readonly int EvtCheckpointLoaded = 2;
+
+        /// <summary>
+        /// Built-in event type: checkpoint was removed. Reasons are: timeout expired, or or it was manually removed, 
+        /// or it was automatically removed by the task session.
+        /// </summary>
+        public static readonly int EvtCheckpointRemoved = 3;
+
+        /// <summary>
+        /// Built-in event type: node joined topology. New node has been discovered and joined grid topology. Note that 
+        /// even though a node has been discovered there could be a number of warnings in the log. In certain 
+        /// situations Ignite doesn't prevent a node from joining but prints warning messages into the log.
+        /// </summary>
+        public static readonly int EvtNodeJoined = 10;
+
+        /// <summary>
+        /// Built-in event type: node has normally left topology.
+        /// </summary>
+        public static readonly int EvtNodeLeft = 11;
+
+        /// <summary>
+        /// Built-in event type: node failed. Ignite detected that node has presumably crashed and is considered 
+        /// failed.
+        /// </summary>
+        public static readonly int EvtNodeFailed = 12;
+
+        /// <summary>
+        /// Built-in event type: node metrics updated. Generated when node's metrics are updated. In most cases this 
+        /// callback is invoked with every heartbeat received from a node (including local node).
+        /// </summary>
+        public static readonly int EvtNodeMetricsUpdated = 13;
+
+        /// <summary>
+        /// Built-in event type: local node segmented. Generated when node determines that it runs in invalid network 
+        /// segment.
+        /// </summary>
+        public static readonly int EvtNodeSegmented = 14;
+
+        /// <summary>
+        /// Built-in event type: client node disconnected.
+        /// </summary>
+        public static readonly int EvtClientNodeDisconnected = 16;
+
+        /// <summary>
+        /// Built-in event type: client node reconnected.
+        /// </summary>
+        public static readonly int EvtClientNodeReconnected = 17;
+
+        /// <summary>
+        /// Built-in event type: task started.
+        /// </summary>
+        public static readonly int EvtTaskStarted = 20;
+
+        /// <summary>
+        /// Built-in event type: task finished. Task got finished. This event is triggered every time a task finished 
+        /// without exception.
+        /// </summary>
+        public static readonly int EvtTaskFinished = 21;
+
+        /// <summary>
+        /// Built-in event type: task failed. Task failed. This event is triggered every time a task finished with an 
+        /// exception. Note that prior to this event, there could be other events recorded specific to the failure.
+        /// </summary>
+        public static readonly int EvtTaskFailed = 22;
+
+        /// <summary>
+        /// Built-in event type: task timed out.
+        /// </summary>
+        public static readonly int EvtTaskTimedout = 23;
+
+        /// <summary>
+        /// Built-in event type: task session attribute set.
+        /// </summary>
+        public static readonly int EvtTaskSessionAttrSet = 24;
+
+        /// <summary>
+        /// Built-in event type: task reduced.
+        /// </summary>
+        public static readonly int EvtTaskReduced = 25;
+
+        /// <summary>
+        /// Built-in event type: Ignite job was mapped in {@link org.apache.ignite.compute.ComputeTask#map(List, Object)} 
+        /// method.
+        /// </summary>
+        public static readonly int EvtJobMapped = 40;
+
+        /// <summary>
+        /// Built-in event type: Ignite job result was received by {@link 
+        /// org.apache.ignite.compute.ComputeTask#result(org.apache.ignite.compute.ComputeJobResult, List)} method.
+        /// </summary>
+        public static readonly int EvtJobResulted = 41;
+
+        /// <summary>
+        /// Built-in event type: Ignite job failed over.
+        /// </summary>
+        public static readonly int EvtJobFailedOver = 43;
+
+        /// <summary>
+        /// Built-in event type: Ignite job started.
+        /// </summary>
+        public static readonly int EvtJobStarted = 44;
+
+        /// <summary>
+        /// Built-in event type: Ignite job finished. Job has successfully completed and produced a result which from the 
+        /// user perspective can still be either negative or positive.
+        /// </summary>
+        public static readonly int EvtJobFinished = 45;
+
+        /// <summary>
+        /// Built-in event type: Ignite job timed out.
+        /// </summary>
+        public static readonly int EvtJobTimedout = 46;
+
+        /// <summary>
+        /// Built-in event type: Ignite job rejected during collision resolution.
+        /// </summary>
+        public static readonly int EvtJobRejected = 47;
+
+        /// <summary>
+        /// Built-in event type: Ignite job failed. Job has failed. This means that there was some error event during job 
+        /// execution and job did not produce a result.
+        /// </summary>
+        public static readonly int EvtJobFailed = 48;
+
+        /// <summary>
+        /// Built-in event type: Ignite job queued. Job arrived for execution and has been queued (added to passive queue 
+        /// during collision resolution).
+        /// </summary>
+        public static readonly int EvtJobQueued = 49;
+
+        /// <summary>
+        /// Built-in event type: Ignite job cancelled.
+        /// </summary>
+        public static readonly int EvtJobCancelled = 50;
+
+        /// <summary>
+        /// Built-in event type: entry created.
+        /// </summary>
+        public static readonly int EvtCacheEntryCreated = 60;
+
+        /// <summary>
+        /// Built-in event type: entry destroyed.
+        /// </summary>
+        public static readonly int EvtCacheEntryDestroyed = 61;
+
+        /// <summary>
+        /// Built-in event type: entry evicted.
+        /// </summary>
+        public static readonly int EvtCacheEntryEvicted = 62;
+
+        /// <summary>
+        /// Built-in event type: object put.
+        /// </summary>
+        public static readonly int EvtCacheObjectPut = 63;
+
+        /// <summary>
+        /// Built-in event type: object read.
+        /// </summary>
+        public static readonly int EvtCacheObjectRead = 64;
+
+        /// <summary>
+        /// Built-in event type: object removed.
+        /// </summary>
+        public static readonly int EvtCacheObjectRemoved = 65;
+
+        /// <summary>
+        /// Built-in event type: object locked.
+        /// </summary>
+        public static readonly int EvtCacheObjectLocked = 66;
+
+        /// <summary>
+        /// Built-in event type: object unlocked.
+        /// </summary>
+        public static readonly int EvtCacheObjectUnlocked = 67;
+
+        /// <summary>
+        /// Built-in event type: cache object swapped from swap storage.
+        /// </summary>
+        public static readonly int EvtCacheObjectSwapped = 68;
+
+        /// <summary>
+        /// Built-in event type: cache object unswapped from swap storage.
+        /// </summary>
+        public static readonly int EvtCacheObjectUnswapped = 69;
+
+        /// <summary>
+        /// Built-in event type: cache object was expired when reading it.
+        /// </summary>
+        public static readonly int EvtCacheObjectExpired = 70;
+
+        /// <summary>
+        /// Built-in event type: swap space data read.
+        /// </summary>
+        public static readonly int EvtSwapSpaceDataRead = 71;
+
+        /// <summary>
+        /// Built-in event type: swap space data stored.
+        /// </summary>
+        public static readonly int EvtSwapSpaceDataStored = 72;
+
+        /// <summary>
+        /// Built-in event type: swap space data removed.
+        /// </summary>
+        public static readonly int EvtSwapSpaceDataRemoved = 73;
+
+        /// <summary>
+        /// Built-in event type: swap space cleared.
+        /// </summary>
+        public static readonly int EvtSwapSpaceCleared = 74;
+
+        /// <summary>
+        /// Built-in event type: swap space data evicted.
+        /// </summary>
+        public static readonly int EvtSwapSpaceDataEvicted = 75;
+
+        /// <summary>
+        /// Built-in event type: cache object stored in off-heap storage.
+        /// </summary>
+        public static readonly int EvtCacheObjectToOffheap = 76;
+
+        /// <summary>
+        /// Built-in event type: cache object moved from off-heap storage back into memory.
+        /// </summary>
+        public static readonly int EvtCacheObjectFromOffheap = 77;
+
+        /// <summary>
+        /// Built-in event type: cache rebalance started.
+        /// </summary>
+        public static readonly int EvtCacheRebalanceStarted = 80;
+
+        /// <summary>
+        /// Built-in event type: cache rebalance stopped.
+        /// </summary>
+        public static readonly int EvtCacheRebalanceStopped = 81;
+
+        /// <summary>
+        /// Built-in event type: cache partition loaded.
+        /// </summary>
+        public static readonly int EvtCacheRebalancePartLoaded = 82;
+
+        /// <summary>
+        /// Built-in event type: cache partition unloaded.
+        /// </summary>
+        public static readonly int EvtCacheRebalancePartUnloaded = 83;
+
+        /// <summary>
+        /// Built-in event type: cache entry rebalanced.
+        /// </summary>
+        public static readonly int EvtCacheRebalanceObjectLoaded = 84;
+
+        /// <summary>
+        /// Built-in event type: cache entry unloaded.
+        /// </summary>
+        public static readonly int EvtCacheRebalanceObjectUnloaded = 85;
+
+        /// <summary>
+        /// Built-in event type: all nodes that hold partition left topology.
+        /// </summary>
+        public static readonly int EvtCacheRebalancePartDataLost = 86;
+
+        /// <summary>
+        /// Built-in event type: query executed.
+        /// </summary>
+        public static readonly int EvtCacheQueryExecuted = 96;
+
+        /// <summary>
+        /// Built-in event type: query entry read.
+        /// </summary>
+        public static readonly int EvtCacheQueryObjectRead = 97;
+
+        /// <summary>
+        /// Built-in event type: cache started.
+        /// </summary>
+        public static readonly int EvtCacheStarted = 98;
+
+        /// <summary>
+        /// Built-in event type: cache started.
+        /// </summary>
+        public static readonly int EvtCacheStopped = 99;
+
+        /// <summary>
+        /// Built-in event type: cache nodes left.
+        /// </summary>
+        public static readonly int EvtCacheNodesLeft = 100;
+
+        /// <summary>
+        /// All events indicating an error or failure condition. It is convenient to use when fetching all events 
+        /// indicating error or failure.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsError =
+        {
+            EvtJobTimedout,
+            EvtJobFailed,
+            EvtJobFailedOver,
+            EvtJobRejected,
+            EvtJobCancelled,
+            EvtTaskTimedout,
+            EvtTaskFailed,
+            EvtCacheRebalanceStarted,
+            EvtCacheRebalanceStopped
+        };
+
+        /// <summary>
+        /// All discovery events except for <see cref="EvtNodeMetricsUpdated" />. Subscription to <see 
+        /// cref="EvtNodeMetricsUpdated" /> can generate massive amount of event processing in most cases is not 
+        /// necessary. If this event is indeed required you can subscribe to it individually or use <see 
+        /// cref="EvtsDiscoveryAll" /> array.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsDiscovery =
+        {
+            EvtNodeJoined,
+            EvtNodeLeft,
+            EvtNodeFailed,
+            EvtNodeSegmented,
+            EvtClientNodeDisconnected,
+            EvtClientNodeReconnected
+        };
+
+        /// <summary>
+        /// All discovery events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsDiscoveryAll =
+        {
+            EvtNodeJoined,
+            EvtNodeLeft,
+            EvtNodeFailed,
+            EvtNodeSegmented,
+            EvtNodeMetricsUpdated,
+            EvtClientNodeDisconnected,
+            EvtClientNodeReconnected
+        };
+
+        /// <summary>
+        /// All Ignite job execution events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsJobExecution =
+        {
+            EvtJobMapped,
+            EvtJobResulted,
+            EvtJobFailedOver,
+            EvtJobStarted,
+            EvtJobFinished,
+            EvtJobTimedout,
+            EvtJobRejected,
+            EvtJobFailed,
+            EvtJobQueued,
+            EvtJobCancelled
+        };
+
+        /// <summary>
+        /// All Ignite task execution events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsTaskExecution =
+        {
+            EvtTaskStarted,
+            EvtTaskFinished,
+            EvtTaskFailed,
+            EvtTaskTimedout,
+            EvtTaskSessionAttrSet,
+            EvtTaskReduced
+        };
+
+        /// <summary>
+        /// All cache events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsCache =
+        {
+            EvtCacheEntryCreated,
+            EvtCacheEntryDestroyed,
+            EvtCacheObjectPut,
+            EvtCacheObjectRead,
+            EvtCacheObjectRemoved,
+            EvtCacheObjectLocked,
+            EvtCacheObjectUnlocked,
+            EvtCacheObjectSwapped,
+            EvtCacheObjectUnswapped,
+            EvtCacheObjectExpired
+        };
+
+        /// <summary>
+        /// All cache rebalance events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsCacheRebalance =
+        {
+            EvtCacheRebalanceStarted,
+            EvtCacheRebalanceStopped,
+            EvtCacheRebalancePartLoaded,
+            EvtCacheRebalancePartUnloaded,
+            EvtCacheRebalanceObjectLoaded,
+            EvtCacheRebalanceObjectUnloaded,
+            EvtCacheRebalancePartDataLost
+        };
+
+        /// <summary>
+        /// All cache lifecycle events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsCacheLifecycle =
+        {
+            EvtCacheStarted,
+            EvtCacheStopped,
+            EvtCacheNodesLeft
+        };
+
+        /// <summary>
+        /// All cache query events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsCacheQuery =
+        {
+            EvtCacheQueryExecuted,
+            EvtCacheQueryObjectRead
+        };
+
+        /// <summary>
+        /// All swap space events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsSwapspace =
+        {
+            EvtSwapSpaceCleared,
+            EvtSwapSpaceDataRemoved,
+            EvtSwapSpaceDataRead,
+            EvtSwapSpaceDataStored,
+            EvtSwapSpaceDataEvicted
+        };
+
+        /// <summary>
+        /// All Ignite events.
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsAll = GetAllEvents();
+
+        /// <summary>
+        /// All Ignite events (<b>excluding</b> metric update event).
+        /// </summary>
+        [SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly",
+            Justification = "Breaking change. Should be fixed in the next non-compatible release.")]
+        public static readonly int[] EvtsAllMinusMetricUpdate =
+            EvtsAll.Where(x => x != EvtNodeMetricsUpdated).ToArray();
+
+        /// <summary>
+        /// Gets all the events.
+        /// </summary>
+        /// <returns>All event ids.</returns>
+        private static int[] GetAllEvents()
+        {
+            return typeof (EventType).GetFields(BindingFlags.Public | BindingFlags.Static)
+                .Where(x => x.FieldType == typeof (int))
+                .Select(x => (int) x.GetValue(null)).ToArray();
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvent.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvent.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvent.cs
new file mode 100644
index 0000000..181aeef
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvent.cs
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Common;
+
+    /// <summary>
+    /// Represents a Ignite event.
+    /// </summary>
+    public interface IEvent
+    {
+        /// <summary>
+        /// Gets globally unique ID of this event.
+        /// </summary>
+        IgniteGuid Id { get; }
+
+        /// <summary>
+        /// Gets locally unique ID that is atomically incremented for each event. Unlike global <see cref="Id" />
+        /// this local ID can be used for ordering events on this node. 
+        /// <para/> 
+        /// Note that for performance considerations Ignite doesn't order events globally.
+        /// </summary>
+        long LocalOrder { get; }
+
+        /// <summary>
+        /// Node where event occurred and was recorded.
+        /// </summary>
+        IClusterNode Node { get; }
+
+        /// <summary>
+        /// Gets optional message for this event.
+        /// </summary>
+        string Message { get; }
+
+        /// <summary>
+        /// Gets type of this event. All system event types are defined in <see cref="EventType"/>
+        /// </summary>
+        int Type { get; }
+
+        /// <summary>
+        /// Gets name of this event.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Gets event timestamp. Timestamp is local to the node on which this event was produced. 
+        /// Note that more than one event can be generated with the same timestamp. 
+        /// For ordering purposes use <see cref="LocalOrder"/> instead.
+        /// </summary>
+        DateTime TimeStamp { get; }
+
+        /// <summary>
+        /// Gets shortened version of ToString result.
+        /// </summary>
+        string ToShortString();
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEventFilter.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEventFilter.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEventFilter.cs
new file mode 100644
index 0000000..7523c52
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEventFilter.cs
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+
+    /// <summary>
+    /// Represents an event filter.
+    /// </summary>
+    /// <typeparam name="T">Event type.</typeparam>
+    public interface IEventFilter<in T> where T : IEvent
+    {
+        /// <summary>
+        /// Determines whether specified event passes this filtger.
+        /// </summary>
+        /// <param name="nodeId">Node identifier.</param>
+        /// <param name="evt">Event.</param>
+        /// <returns>Value indicating whether specified event passes this filtger.</returns>
+        bool Invoke(Guid nodeId, T evt);
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/5cec202c/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvents.cs
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvents.cs b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvents.cs
new file mode 100644
index 0000000..e13513c
--- /dev/null
+++ b/modules/platform/src/main/dotnet/Apache.Ignite.Core/Events/IEvents.cs
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Events
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Common;
+
+    /// <summary>
+    /// Provides functionality for local and remote event notifications on nodes defined by <see cref="ClusterGroup"/>.
+    /// <para/>
+    /// All members are thread-safe and may be used concurrently from multiple threads.
+    /// </summary>
+    public interface IEvents : IAsyncSupport<IEvents>
+    {
+        /// <summary>
+        /// Gets the cluster group to which this instance belongs.
+        /// </summary>
+        IClusterGroup ClusterGroup { get; }
+
+        /// <summary>
+        /// Queries nodes in this cluster group for events using passed in predicate filter for event selection.
+        /// </summary>
+        /// <typeparam name="T">Type of events.</typeparam>
+        /// <param name="filter">Predicate filter used to query events on remote nodes.</param>
+        /// <param name="timeout">Maximum time to wait for result, null or 0 to wait forever.</param>
+        /// <param name="types">Event types to be queried.</param>
+        /// <returns>Collection of Ignite events returned from specified nodes.</returns>
+        [AsyncSupported]
+        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists")]
+        List<T> RemoteQuery<T>(IEventFilter<T> filter, TimeSpan? timeout = null, params int[] types) 
+            where T : IEvent;
+
+        /// <summary>
+        /// Adds event listener for specified events to all nodes in the cluster group (possibly including local node 
+        /// if it belongs to the cluster group as well). This means that all events occurring on any node within this 
+        /// cluster group that pass remote filter will be sent to local node for local listener notifications.
+        /// <para/>
+        /// The listener can be unsubscribed automatically if local node stops, if localListener callback 
+        /// returns false or if <see cref="StopRemoteListen"/> is called.
+        /// </summary>
+        /// <typeparam name="T">Type of events.</typeparam>
+        /// <param name="bufSize">Remote events buffer size. Events from remote nodes won't be sent until buffer
+        /// is full or time interval is exceeded.</param>
+        /// <param name="interval">Maximum time interval after which events from remote node will be sent. Events
+        /// from remote nodes won't be sent until buffer is full or time interval is exceeded.</param>
+        /// <param name="autoUnsubscribe">Flag indicating that event listeners on remote nodes should be automatically 
+        /// unregistered if master node (node that initiated event listening) leaves topology. 
+        /// If this flag is false, listeners will be unregistered only when <see cref="StopRemoteListen"/>
+        /// method is called, or the localListener returns false.</param>
+        /// <param name="localListener"> Listener callback that is called on local node. If null, these events will 
+        /// be handled on remote nodes by passed in remoteFilter.</param>
+        /// <param name="remoteFilter">
+        /// Filter callback that is called on remote node. Only events that pass the remote filter will be 
+        /// sent to local node. If null, all events of specified types will be sent to local node. 
+        /// This remote filter can be used to pre-handle events remotely, before they are passed in to local callback.
+        /// It will be auto-unsubscribed on the node where event occurred in case if it returns false.
+        /// </param>
+        /// <param name="types">
+        /// Types of events to listen for. If not provided, all events that pass the provided remote filter 
+        /// will be sent to local node.
+        /// </param>
+        /// <returns>
+        /// Operation ID that can be passed to <see cref="StopRemoteListen"/> method to stop listening.
+        /// </returns>
+        [AsyncSupported]
+        Guid RemoteListen<T>(int bufSize = 1, TimeSpan? interval = null, bool autoUnsubscribe = true,
+            IEventFilter<T> localListener = null, IEventFilter<T> remoteFilter = null, params int[] types) 
+            where T : IEvent;
+
+        /// <summary>
+        /// Stops listening to remote events. This will unregister all listeners identified with provided operation ID 
+        /// on all nodes defined by <see cref="ClusterGroup"/>.
+        /// </summary>
+        /// <param name="opId">Operation ID that was returned from <see cref="RemoteListen{T}"/>.</param>
+        [AsyncSupported]
+        void StopRemoteListen(Guid opId);
+
+        /// <summary>
+        /// Waits for the specified events.
+        /// </summary>
+        /// <param name="types">Types of the events to wait for. 
+        /// If not provided, all events will be passed to the filter.</param>
+        /// <returns>Ignite event.</returns>
+        [AsyncSupported]
+        IEvent WaitForLocal(params int[] types);
+
+        /// <summary>
+        /// Waits for the specified events.
+        /// </summary>
+        /// <typeparam name="T">Type of events.</typeparam>
+        /// <param name="filter">Optional filtering predicate. Event wait will end as soon as it returns false.</param>
+        /// <param name="types">Types of the events to wait for. 
+        /// If not provided, all events will be passed to the filter.</param>
+        /// <returns>Ignite event.</returns>
+        [AsyncSupported]
+        T WaitForLocal<T>(IEventFilter<T> filter, params int[] types) where T : IEvent;
+
+        /// <summary>
+        /// Queries local node for events using of specified types.
+        /// </summary>
+        /// <param name="types">Event types to be queried. Optional.</param>
+        /// <returns>Collection of Ignite events found on local node.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists")]
+        List<IEvent> LocalQuery(params int[] types);
+
+        /// <summary>
+        /// Records customer user generated event. All registered local listeners will be notified.
+        /// <para/>
+        /// NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
+        /// internal Ignite events and should not be used by user-defined events.
+        /// Attempt to record internal event with this method will cause <see cref="ArgumentException"/> to be thrown.
+        /// </summary>
+        /// <param name="evt">Locally generated event.</param>
+        /// <exception cref="ArgumentException">If event type is within Ignite reserved range (1 � 1000)</exception>
+        void RecordLocal(IEvent evt);
+
+        /// <summary>
+        /// Adds an event listener for local events. Note that listener will be added regardless of whether 
+        /// local node is in this cluster group or not.
+        /// </summary>
+        /// <typeparam name="T">Type of events.</typeparam>
+        /// <param name="listener">Predicate that is called on each received event. If predicate returns false,
+        /// it will be unregistered and will stop receiving events.</param>
+        /// <param name="types">Event types for which this listener will be notified, should not be empty.</param>
+        void LocalListen<T>(IEventFilter<T> listener, params int[] types) where T : IEvent;
+
+        /// <summary>
+        /// Removes local event listener.
+        /// </summary>
+        /// <typeparam name="T">Type of events.</typeparam>
+        /// <param name="listener">Local event listener to remove.</param>
+        /// <param name="types">Types of events for which to remove listener. If not specified, then listener
+        /// will be removed for all types it was registered for.</param>
+        /// <returns>True if listener was removed, false otherwise.</returns>
+        bool StopLocalListen<T>(IEventFilter<T> listener, params int[] types) where T : IEvent;
+
+        /// <summary>
+        /// Enables provided events. Allows to start recording events that were disabled before. 
+        /// Note that provided events will be enabled regardless of whether local node is in this cluster group or not.
+        /// </summary>
+        /// <param name="types">Events to enable.</param>
+        void EnableLocal(params int[] types);
+
+        /// <summary>
+        /// Disables provided events. Allows to stop recording events that were enabled before. Note that specified 
+        /// events will be disabled regardless of whether local node is in this cluster group or not.
+        /// </summary>
+        /// <param name="types">Events to disable.</param>
+        void DisableLocal(params int[] types);
+
+        /// <summary>
+        /// Gets types of enabled events.
+        /// </summary>
+        /// <returns>Types of enabled events.</returns>
+        int[] GetEnabledEvents();
+
+        /// <summary>
+        /// Determines whether the specified event is enabled.
+        /// </summary>
+        /// <param name="type">Event type.</param>
+        /// <returns>Value indicating whether the specified event is enabled.</returns>
+        bool IsEnabled(int type);
+    }
+}
\ No newline at end of file


Mime
View raw message