<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<META NAME="ROBOTS" CONTENT="NOINDEX">
<link rel="canonical" href="https://ignite.apache.org/releases/1.7.0/dotnetdoc/class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html" />
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.9.1"/>
<title>Apache Ignite.NET: Apache.Ignite.Core.Events.DiscoveryEvent Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="navtree.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="resize.js"></script>
<script type="text/javascript" src="navtreedata.js"></script>
<script type="text/javascript" src="navtree.js"></script>
<script type="text/javascript">
  $(document).ready(initResizable);
  $(window).load(resizeHeight);
</script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

</script></head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectlogo"><img alt="Logo" src="ignite_logo.png"/></td>
  <td style="padding-left: 0.5em;">
   <div id="projectname">Apache Ignite.NET
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.9.1 -->
</div><!-- top -->
<div id="side-nav" class="ui-resizable side-nav-resizable">
  <div id="nav-tree">
    <div id="nav-tree-contents">
      <div id="nav-sync" class="sync"></div>
    </div>
  </div>
  <div id="splitbar" style="-moz-user-select:none;" 
       class="ui-resizable-handle">
  </div>
</div>
<script type="text/javascript">
$(document).ready(function(){initNavTree('class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html','');});
</script>
<div id="doc-content">
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Ignite.Core.Events.DiscoveryEvent Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p>Grid discovery event.  
 <a href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Ignite.Core.Events.DiscoveryEvent:</div>
<div class="dyncontent">
 <div class="center">
  <img src="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.png" usemap="#Apache.Ignite.Core.Events.DiscoveryEvent_map" alt=""/>
  <map id="Apache.Ignite.Core.Events.DiscoveryEvent_map" name="Apache.Ignite.Core.Events.DiscoveryEvent_map">
<area href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html" title="Base event implementation. " alt="Apache.Ignite.Core.Events.EventBase" shape="rect" coords="134,56,392,80"/>
<area href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html" title="Represents a Ignite event. " alt="Apache.Ignite.Core.Events.IEvent" shape="rect" coords="0,0,258,24"/>
</map>
 </div></div>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:af92dd318f42524278bafe69a331a730c"><td class="memItemLeft" align="right" valign="top">override string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html#af92dd318f42524278bafe69a331a730c">ToShortString</a> ()</td></tr>
<tr class="memdesc:af92dd318f42524278bafe69a331a730c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets shortened version of ToString result.  <a href="#af92dd318f42524278bafe69a331a730c">More...</a><br /></td></tr>
<tr class="separator:af92dd318f42524278bafe69a331a730c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html">Apache.Ignite.Core.Events.EventBase</a></td></tr>
<tr class="memitem:a1c94907971523fbd85ddb18a22d70363 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a1c94907971523fbd85ddb18a22d70363">Equals</a> (<a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html">EventBase</a> other)</td></tr>
<tr class="memdesc:a1c94907971523fbd85ddb18a22d70363 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Determines whether the specified object is equal to this instance.  <a href="#a1c94907971523fbd85ddb18a22d70363">More...</a><br /></td></tr>
<tr class="separator:a1c94907971523fbd85ddb18a22d70363 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afa783e6c77e5e5acddf5243a10317860 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">override bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#afa783e6c77e5e5acddf5243a10317860">Equals</a> (object obj)</td></tr>
<tr class="memdesc:afa783e6c77e5e5acddf5243a10317860 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Determines whether the specified object is equal to this instance.  <a href="#afa783e6c77e5e5acddf5243a10317860">More...</a><br /></td></tr>
<tr class="separator:afa783e6c77e5e5acddf5243a10317860 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a879e14602ba3726905b7d574f79ee647 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">override int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a879e14602ba3726905b7d574f79ee647">GetHashCode</a> ()</td></tr>
<tr class="memdesc:a879e14602ba3726905b7d574f79ee647 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a hash code for this instance.  <a href="#a879e14602ba3726905b7d574f79ee647">More...</a><br /></td></tr>
<tr class="separator:a879e14602ba3726905b7d574f79ee647 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a846e9bff6cc9a9d67b5d54dd140b5804 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">override string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a846e9bff6cc9a9d67b5d54dd140b5804">ToString</a> ()</td></tr>
<tr class="memdesc:a846e9bff6cc9a9d67b5d54dd140b5804 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a string that represents this instance.  <a href="#a846e9bff6cc9a9d67b5d54dd140b5804">More...</a><br /></td></tr>
<tr class="separator:a846e9bff6cc9a9d67b5d54dd140b5804 inherit pub_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="properties"></a>
Properties</h2></td></tr>
<tr class="memitem:af67956ba538e5c6f3a29d690c916c3e9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html#af67956ba538e5c6f3a29d690c916c3e9">EventNode</a><code> [get]</code></td></tr>
<tr class="memdesc:af67956ba538e5c6f3a29d690c916c3e9"><td class="mdescLeft">&#160;</td><td class="mdescRight">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.  <a href="#af67956ba538e5c6f3a29d690c916c3e9">More...</a><br /></td></tr>
<tr class="separator:af67956ba538e5c6f3a29d690c916c3e9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aec8eca3048bf14755eb4aa8251be195e"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html#aec8eca3048bf14755eb4aa8251be195e">TopologyVersion</a><code> [get]</code></td></tr>
<tr class="memdesc:aec8eca3048bf14755eb4aa8251be195e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets topology version if this event is raised on topology change and configured discovery SPI implementation supports topology versioning.  <a href="#aec8eca3048bf14755eb4aa8251be195e">More...</a><br /></td></tr>
<tr class="separator:aec8eca3048bf14755eb4aa8251be195e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abeaae643d415ecc46c0cc794fc60cb62"><td class="memItemLeft" align="right" valign="top">ICollection&lt; <a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html#abeaae643d415ecc46c0cc794fc60cb62">TopologyNodes</a><code> [get]</code></td></tr>
<tr class="memdesc:abeaae643d415ecc46c0cc794fc60cb62"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets topology nodes from topology snapshot. If SPI implementation does not support versioning, the best effort snapshot will be captured.  <a href="#abeaae643d415ecc46c0cc794fc60cb62">More...</a><br /></td></tr>
<tr class="separator:abeaae643d415ecc46c0cc794fc60cb62"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td colspan="2" onclick="javascript:toggleInherit('properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html">Apache.Ignite.Core.Events.EventBase</a></td></tr>
<tr class="memitem:a34a38098ac0766e92641ede36f7f1aec inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="struct_apache_1_1_ignite_1_1_core_1_1_common_1_1_ignite_guid.html">IgniteGuid</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a34a38098ac0766e92641ede36f7f1aec">Id</a><code> [get]</code></td></tr>
<tr class="memdesc:a34a38098ac0766e92641ede36f7f1aec inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets globally unique ID of this event.  <a href="#a34a38098ac0766e92641ede36f7f1aec">More...</a><br /></td></tr>
<tr class="separator:a34a38098ac0766e92641ede36f7f1aec inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:add7727a6b14544b07d5e5945132bc56a inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#add7727a6b14544b07d5e5945132bc56a">LocalOrder</a><code> [get]</code></td></tr>
<tr class="memdesc:add7727a6b14544b07d5e5945132bc56a inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets locally unique ID that is atomically incremented for each event. Unlike global <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a34a38098ac0766e92641ede36f7f1aec" title="Gets globally unique ID of this event. ">Id</a> this local ID can be used for ordering events on this node.  <a href="#add7727a6b14544b07d5e5945132bc56a">More...</a><br /></td></tr>
<tr class="separator:add7727a6b14544b07d5e5945132bc56a inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aab4741db6296f4e90ef00b67a5252487 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#aab4741db6296f4e90ef00b67a5252487">Node</a><code> [get]</code></td></tr>
<tr class="memdesc:aab4741db6296f4e90ef00b67a5252487 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Node where event occurred and was recorded.  <a href="#aab4741db6296f4e90ef00b67a5252487">More...</a><br /></td></tr>
<tr class="separator:aab4741db6296f4e90ef00b67a5252487 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a320a50c7e83e6999905abe0175b08bbf inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a320a50c7e83e6999905abe0175b08bbf">Message</a><code> [get]</code></td></tr>
<tr class="memdesc:a320a50c7e83e6999905abe0175b08bbf inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets optional message for this event.  <a href="#a320a50c7e83e6999905abe0175b08bbf">More...</a><br /></td></tr>
<tr class="separator:a320a50c7e83e6999905abe0175b08bbf inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0fe0cad967160e3ed233f8c4dc3466c7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a0fe0cad967160e3ed233f8c4dc3466c7">Type</a><code> [get]</code></td></tr>
<tr class="memdesc:a0fe0cad967160e3ed233f8c4dc3466c7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets type of this event. All system event types are defined in <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_type.html" title="Contains event type constants. The decision to use class and not enumeration is dictated by allowing ...">EventType</a>  <a href="#a0fe0cad967160e3ed233f8c4dc3466c7">More...</a><br /></td></tr>
<tr class="separator:a0fe0cad967160e3ed233f8c4dc3466c7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a957884bd4c4733017534172397698c83 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a957884bd4c4733017534172397698c83">Name</a><code> [get]</code></td></tr>
<tr class="memdesc:a957884bd4c4733017534172397698c83 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets name of this event.  <a href="#a957884bd4c4733017534172397698c83">More...</a><br /></td></tr>
<tr class="separator:a957884bd4c4733017534172397698c83 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3a8cf9729366aa1a598f6743c955b9e7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">DateTime&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a3a8cf9729366aa1a598f6743c955b9e7">Timestamp</a><code> [get]</code></td></tr>
<tr class="memdesc:a3a8cf9729366aa1a598f6743c955b9e7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">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 <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#add7727a6b14544b07d5e5945132bc56a" title="Gets locally unique ID that is atomically incremented for each event. Unlike global Id this local ID ...">LocalOrder</a> instead.  <a href="#a3a8cf9729366aa1a598f6743c955b9e7">More...</a><br /></td></tr>
<tr class="separator:a3a8cf9729366aa1a598f6743c955b9e7 inherit properties_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td colspan="2" onclick="javascript:toggleInherit('properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html">Apache.Ignite.Core.Events.IEvent</a></td></tr>
<tr class="memitem:a6d267b8b6602e84e906fad23314eeb8a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top"><a class="el" href="struct_apache_1_1_ignite_1_1_core_1_1_common_1_1_ignite_guid.html">IgniteGuid</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a6d267b8b6602e84e906fad23314eeb8a">Id</a><code> [get]</code></td></tr>
<tr class="memdesc:a6d267b8b6602e84e906fad23314eeb8a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets globally unique ID of this event.  <a href="#a6d267b8b6602e84e906fad23314eeb8a">More...</a><br /></td></tr>
<tr class="separator:a6d267b8b6602e84e906fad23314eeb8a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a703e4feffa1604e7a304f05e4cefbd7a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a703e4feffa1604e7a304f05e4cefbd7a">LocalOrder</a><code> [get]</code></td></tr>
<tr class="memdesc:a703e4feffa1604e7a304f05e4cefbd7a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets locally unique ID that is atomically incremented for each event. Unlike global <a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a6d267b8b6602e84e906fad23314eeb8a" title="Gets globally unique ID of this event. ">Id</a> this local ID can be used for ordering events on this node. Note that for performance considerations Ignite doesn't order events globally.  <a href="#a703e4feffa1604e7a304f05e4cefbd7a">More...</a><br /></td></tr>
<tr class="separator:a703e4feffa1604e7a304f05e4cefbd7a inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4009e7e65b2ec75db1a32b92ffea92d5 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a4009e7e65b2ec75db1a32b92ffea92d5">Node</a><code> [get]</code></td></tr>
<tr class="memdesc:a4009e7e65b2ec75db1a32b92ffea92d5 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Node where event occurred and was recorded.  <a href="#a4009e7e65b2ec75db1a32b92ffea92d5">More...</a><br /></td></tr>
<tr class="separator:a4009e7e65b2ec75db1a32b92ffea92d5 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aad9323237ca6495133ada7fddc568941 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#aad9323237ca6495133ada7fddc568941">Message</a><code> [get]</code></td></tr>
<tr class="memdesc:aad9323237ca6495133ada7fddc568941 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets optional message for this event.  <a href="#aad9323237ca6495133ada7fddc568941">More...</a><br /></td></tr>
<tr class="separator:aad9323237ca6495133ada7fddc568941 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a28debb3b8efba1afeeb5e560192bcaa0 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a28debb3b8efba1afeeb5e560192bcaa0">Type</a><code> [get]</code></td></tr>
<tr class="memdesc:a28debb3b8efba1afeeb5e560192bcaa0 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets type of this event. All system event types are defined in <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_type.html" title="Contains event type constants. The decision to use class and not enumeration is dictated by allowing ...">EventType</a>  <a href="#a28debb3b8efba1afeeb5e560192bcaa0">More...</a><br /></td></tr>
<tr class="separator:a28debb3b8efba1afeeb5e560192bcaa0 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad5c971ed964d2167ddf9247a18a6259c inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#ad5c971ed964d2167ddf9247a18a6259c">Name</a><code> [get]</code></td></tr>
<tr class="memdesc:ad5c971ed964d2167ddf9247a18a6259c inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets name of this event.  <a href="#ad5c971ed964d2167ddf9247a18a6259c">More...</a><br /></td></tr>
<tr class="separator:ad5c971ed964d2167ddf9247a18a6259c inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac4b580163e899350a35a493864e21793 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memItemLeft" align="right" valign="top">DateTime&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#ac4b580163e899350a35a493864e21793">Timestamp</a><code> [get]</code></td></tr>
<tr class="memdesc:ac4b580163e899350a35a493864e21793 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="mdescLeft">&#160;</td><td class="mdescRight">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 <a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event.html#a703e4feffa1604e7a304f05e4cefbd7a" title="Gets locally unique ID that is atomically incremented for each event. Unlike global Id this local ID ...">LocalOrder</a> instead.  <a href="#ac4b580163e899350a35a493864e21793">More...</a><br /></td></tr>
<tr class="separator:ac4b580163e899350a35a493864e21793 inherit properties_interface_apache_1_1_ignite_1_1_core_1_1_events_1_1_i_event"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
Additional Inherited Members</h2></td></tr>
<tr class="inherit_header pro_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html">Apache.Ignite.Core.Events.EventBase</a></td></tr>
<tr class="memitem:af3f9515ffa9d71dc1690f4548901ba86 inherit pro_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#af3f9515ffa9d71dc1690f4548901ba86">EventBase</a> (<a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_binary_1_1_i_binary_raw_reader.html">IBinaryRawReader</a> r)</td></tr>
<tr class="memdesc:af3f9515ffa9d71dc1690f4548901ba86 inherit pro_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initializes a new instance of the <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html" title="Base event implementation. ">EventBase</a> class.  <a href="#af3f9515ffa9d71dc1690f4548901ba86">More...</a><br /></td></tr>
<tr class="separator:af3f9515ffa9d71dc1690f4548901ba86 inherit pro_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pro_static_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td colspan="2" onclick="javascript:toggleInherit('pro_static_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base')"><img src="closed.png" alt="-"/>&#160;Static Protected Member Functions inherited from <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html">Apache.Ignite.Core.Events.EventBase</a></td></tr>
<tr class="memitem:ae0474cd89625acae97a76ab2573656ba inherit pro_static_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memItemLeft" align="right" valign="top">static <a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#ae0474cd89625acae97a76ab2573656ba">ReadNode</a> (<a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_binary_1_1_i_binary_raw_reader.html">IBinaryRawReader</a> reader)</td></tr>
<tr class="memdesc:ae0474cd89625acae97a76ab2573656ba inherit pro_static_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a node from stream.  <a href="#ae0474cd89625acae97a76ab2573656ba">More...</a><br /></td></tr>
<tr class="separator:ae0474cd89625acae97a76ab2573656ba inherit pro_static_methods_class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"></div><h2 class="groupheader">Member Function Documentation</h2>
<a class="anchor" id="af92dd318f42524278bafe69a331a730c"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override string Apache.Ignite.Core.Events.DiscoveryEvent.ToShortString </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reimplemented from <a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_event_base.html#a9852ded15689b42174eebb7af253cdca">Apache.Ignite.Core.Events.EventBase</a>.</p>

</div>
</div>
<h2 class="groupheader">Property Documentation</h2>
<a class="anchor" id="af67956ba538e5c6f3a29d690c916c3e9"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a> Apache.Ignite.Core.Events.DiscoveryEvent.EventNode</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

</div>
</div>
<a class="anchor" id="abeaae643d415ecc46c0cc794fc60cb62"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">ICollection&lt;<a class="el" href="interface_apache_1_1_ignite_1_1_core_1_1_cluster_1_1_i_cluster_node.html">IClusterNode</a>&gt; Apache.Ignite.Core.Events.DiscoveryEvent.TopologyNodes</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

</div>
</div>
<a class="anchor" id="aec8eca3048bf14755eb4aa8251be195e"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Ignite.Core.Events.DiscoveryEvent.TopologyVersion</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

</div>
</div>
</div><!-- contents -->
</div><!-- doc-content -->
<!-- start footer part -->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
  <ul>
    <li class="navelem"><a class="el" href="namespace_apache.html">Apache</a></li><li class="navelem"><a class="el" href="namespace_apache_1_1_ignite.html">Ignite</a></li><li class="navelem"><a class="el" href="namespace_apache_1_1_ignite_1_1_core.html">Core</a></li><li class="navelem"><a class="el" href="namespace_apache_1_1_ignite_1_1_core_1_1_events.html">Events</a></li><li class="navelem"><a class="el" href="class_apache_1_1_ignite_1_1_core_1_1_events_1_1_discovery_event.html">DiscoveryEvent</a></li>
    <li class="footer">Generated on Mon Aug 1 2016 19:40:28 for Apache Ignite.NET by
    <a href="http://www.doxygen.org/index.html">
    <img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.8.9.1 </li>
  </ul>
</div>
</body>
</html>
